Tool Translator++ 4.9.28 Standard Version / Developer Version

[ripno]

Hello, my friends!, could you share some places that offer free provider APIs?
T++ DeepL plugin acting up, and AI models give much better translations these days.
If you want to know more.
I'll start by sharing some popular free providers I'm using now, along with how many free calls you get per day:

You must be registered to see the links

(250/day)

You must be registered to see the links

(200/day)

You must be registered to see the links

(100/day)

You must be registered to see the links

(50/day)
Chutes used to be unlimited, but then one day it changed – now it's just 200/day.
So, friends, can you share any more generous providers?
If you're willing to share, I'd really appreciate it.

A call refers to one request made to the AI server. Each time you send a message or prompt for the AI to process — whether it's a sentence, paragraph, or a block of text — that counts as one call.

For example, if you send one sentence to be translated, that's one API call. If you send 100 sentences in one batch, it's still just one call. That’s why batching multiple lines into a single request is often more efficient, especially when working within daily call limits.

Regarding your usage of the free API calls, it is very likely that your free quota is used up quickly because each API call processes one sentence at a time. If you translate one sentence per call, the number of calls can add up fast, especially if you translate large amounts of text.

To optimize your usage and avoid running out of free calls too quickly, you might consider sending multiple sentences in a single API call if the service supports it. This way, you reduce the number of calls while still getting all your translations done.

For comparison, I usually send up to 200 lines of text in a single request. So even when translating thousands of lines from a visual novel, the quota has been sufficient for me.

You might consider batching more text per call if the API allows it — it can really help optimize usage.

 

[wsg123]

Have you tried these 3? I'm not too well know on AI Models these days

Provider	Free Quota	Notes
LibreTranslate	Unlimited (self-hosted)	Free and open-source. Some public instances available.
Lingva Translate	Unlimited (frontend)	A privacy-focused frontend for Google Translate.
Argos Translate	Unlimited (offline)	Based on OpenNMT. Installable desktop/CLI version.
OpenTDB + FreeTTS API (Speech)	~100/day	For text-to-speech if you want multilingual audio.
Translate-Server (via HuggingFace)	~100/day	Based on MarianMT/MBart models.

Thanks for sharing. The services you recommended all require manual copying from a webpage.
What we really need is a translation method like OpenAI's – something that works without a server or webpage. Just a method that only requires an API key to call.
If I can't find the right solution, I'll give these a shot，
Or wait for the next day.

 

[Osamu Dazai Sensei]

Thanks for sharing. The services you recommended all require manual copying from a webpage.
What we really need is a translation method like OpenAI's – something that works without a server or webpage. Just a method that only requires an API key to call.
If I can't find the right solution, I'll give these a shot，
Or wait for the next day.

Join me on the server then I think I know some guys who knows alot of these more than me though

 

[wsg123]

A call refers to one request made to the AI server. Each time you send a message or prompt for the AI to process — whether it's a sentence, paragraph, or a block of text — that counts as one call.

For example, if you send one sentence to be translated, that's one API call. If you send 100 sentences in one batch, it's still just one call. That’s why batching multiple lines into a single request is often more efficient, especially when working within daily call limits.

Regarding your usage of the free API calls, it is very likely that your free quota is used up quickly because each API call processes one sentence at a time. If you translate one sentence per call, the number of calls can add up fast, especially if you translate large amounts of text.

To optimize your usage and avoid running out of free calls too quickly, you might consider sending multiple sentences in a single API call if the service supports it. This way, you reduce the number of calls while still getting all your translations done.

For comparison, I usually send up to 200 lines of text in a single request. So even when translating thousands of lines from a visual novel, the quota has been sufficient for me.

You might consider batching more text per call if the API allows it — it can really help optimize usage.

I know how these API calls work. We submit text in batches, like chunks of 20 lines at a time.
By the way, each provider also has a daily token limit. Both input and output count toward this limit.

Just to give you an idea:
If we count one English letter as one token, a provider with a 200-token limit could handle about 5,000 English letters per day.
But for a game? A single update version can easily have over 10,000 letters.

 

[ripno]

I know how these API calls work. We submit text in batches, like chunks of 20 lines at a time.
By the way, each provider also has a daily token limit. Both input and output count toward this limit.

Just to give you an idea:
If we count one English letter as one token, a provider with a 200-token limit could handle about 5,000 English letters per day.
But for a game? A single update version can easily have over 10,000 letters.

Just to share my experience — I’ve been using Chutes.ai quite a bit, and so far, I haven’t hit any token/day limit.
For example, the Tyrano game I’m currently translating has 3,113 lines of texts, with a total of 122,515 characters. I was able to process all of that through multiple requests without any issues.
The AI translation part alone was completed in less than an hour, which I found really efficient.

Chutes.ai does apply daily token limits, though they don’t publish specific numbers openly. However, since Chutes uses a serverless AI backend—similar to platforms like Fireworks.ai—we can reasonably infer their limits follow the same structure.

According to Fireworks.ai documentation, the daily token limits are based on the size of the model:
Model Size　　　　　　　　　　　　　　 　　Estimated Daily Token Limit
< 40B parameters　　　　　　　　　　　　　 ~2.5 billion tokens/day
40B–100B parameters　　　　　　　　　　　~1.25 billion tokens/day
> 100B parameters (e.g. DeepSeek-R1)　　~600 million tokens/day

Chutes.ai supports large models like DeepSeek-R1 and LLaMA variants, so it's likely they follow these same quotas. If you prompt a large model with, say, 1,000 tokens per request (input + output), you'd be able to run ~600,000 generations per day with a 100B+ model before hitting the cap.
I think the free plan is actually quite generous for text-based projects like this.

 

[jaden_yuki]

Hello, my friends!, could you share some places that offer free provider APIs?
T++ DeepL plugin acting up, and AI models give much better translations these days.
If you want to know more.
I'll start by sharing some popular free providers I'm using now, along with how many free calls you get per day:

You must be registered to see the links

(250/day)

You must be registered to see the links

(200/day)

You must be registered to see the links

(100/day)

You must be registered to see the links

(50/day)
Chutes used to be unlimited, but then one day it changed – now it's just 200/day.
So, friends, can you share any more generous providers?
If you're willing to share, I'd really appreciate it.

I already knew that chutes would impose a limit someday, but openrouter surprised me. Did they go down from 200/day to 50/day? I'm disappointed

 

[jaden_yuki]

A call refers to one request made to the AI server. Each time you send a message or prompt for the AI to process — whether it's a sentence, paragraph, or a block of text — that counts as one call.

For example, if you send one sentence to be translated, that's one API call. If you send 100 sentences in one batch, it's still just one call. That’s why batching multiple lines into a single request is often more efficient, especially when working within daily call limits.

Regarding your usage of the free API calls, it is very likely that your free quota is used up quickly because each API call processes one sentence at a time. If you translate one sentence per call, the number of calls can add up fast, especially if you translate large amounts of text.

To optimize your usage and avoid running out of free calls too quickly, you might consider sending multiple sentences in a single API call if the service supports it. This way, you reduce the number of calls while still getting all your translations done.

For comparison, I usually send up to 200 lines of text in a single request. So even when translating thousands of lines from a visual novel, the quota has been sufficient for me.

You might consider batching more text per call if the API allows it — it can really help optimize usage.

the more lines you send in a single request, the worse the quality of the translation

 

[wsg123]

I already knew that chutes would impose a limit someday, but openrouter surprised me. Did they go down from 200/day to 50/day? I'm disappointed

yeah,openrouter is not generous.

 

[archedio]

Chutes used to be unlimited, but then one day it changed – now it's just 200/day.
So, friends, can you share any more generous providers?
If you're willing to share, I'd really appreciate it.

Wait, holy... chutes isn't unlimited anymore? This is the first I'm hearing about it. What a massive shame...
Though to be fair, I only really use it for DeepSeek-V3-0324 anyway.

 

[ripno]

the more lines you send in a single request, the worse the quality of the translation

I understand the concern, but that’s **not entirely accurate**—especially when using a proper setup like a **Python script** and a capable model like **DeepSeek**.

### Here’s what you need to know:

1. **Translation quality doesn’t necessarily degrade with longer text**, as long as the text fits within the model’s token limit. Models like **DeepSeek** (including other AIs with big parameters) are fully capable of handling long inputs accurately.

2. I’m using a **Python script** that:
- Sends **hundreds of lines of text** in one request
- Structures prompts clearly
- Ensures the output is **fully received**, without getting cut off mid-way — meaning you get a **complete response in one go**, without having to ask for "continue" or follow-up chunks
- Bypasses browser limitations like output truncation or “Continue” prompts

3. Because the full text is processed in one batch, the model:
- Maintains **context**
- Keeps **style and terminology consistent**
- Produces **clean, high-quality translations**, even with long content

The downside is that you need to manually copy the original text and paste it into the Python script, then after the translation is received, you have to copy the translated text and save it separately. This process isn’t fully automated but helps maintain translation quality for long texts.

4. I’m currently using **DeepSeek models** via the **chutes.ai server**, which hosts high-performance open-source models.

5. I’m aware of the newly released **DeepSeek-TNG-R1T2-Chimera** (July 2025), which combines the strengths of several DeepSeek variants. I haven’t used it yet, but it's worth checking out if you're into model testing and optimization.


### TL;DR

- **It’s not about how long the text is**, it’s how you send it and which model you use.
- With a proper script and models like **DeepSeek**, long texts can be translated **consistently and accurately**.
- If users are only using browser-based interfaces and relying on "Continue" commands, **inconsistencies are expected**.

 

[jaden_yuki]

The downside is that you need to manually copy the original text and paste it into the Python script, then after the translation is received, you have to copy the translated text and save it separately. This process isn’t fully automated but helps maintain translation quality for long texts.

not really:

You must be registered to see the links

(for translator++)
but the best one is:

You must be registered to see the links

 

[ripno]

not really:

You must be registered to see the links

(for translator++)
but the best one is:

You must be registered to see the links

I’ll give LinguaGacha a try. It seems promising for streamlining the translation workflow.

By the way, could you share a complete guide or setup instructions for the GPT4Free addon for Translator++? Including the parameters that need to be filled.
I’d really appreciate a step-by-step explanation, since I’m interested in testing it out for my workflow.

 

[wsg123]

I’ll give LinguaGacha a try. It seems promising for streamlining the translation workflow.

By the way, could you share a complete guide or setup instructions for the GPT4Free addon for Translator++? Including the parameters that need to be filled.
I’d really appreciate a step-by-step explanation, since I’m interested in testing it out for my workflow.

I tried LinguaGacha, but it still seems to require an API KEY to work.
So the question comes back to service providers – where can we find one that offers really generous usage limits?

LinguaGacha does have a local interface, but you'd need at least an 8GB VRAM graphics card to get decent translation quality.
Plus, when translating, it might take up over 90% of your GPU, so you can't do much else on your PC besides LinguaGacha.

About that GPT4Free addon you mentioned – is that the plugin for GPT4-all?
If so, that plugin also uses a local interface. You can find details in T++'s official documentation.

 

[Hero_Protagonist]

I understand the concern, but that’s **not entirely accurate**—especially when using a proper setup like a **Python script** and a capable model like **DeepSeek**.

### Here’s what you need to know:

1. **Translation quality doesn’t necessarily degrade with longer text**, as long as the text fits within the model’s token limit. Models like **DeepSeek** (including other AIs with big parameters) are fully capable of handling long inputs accurately.

2. I’m using a **Python script** that:
- Sends **hundreds of lines of text** in one request
- Structures prompts clearly
- Ensures the output is **fully received**, without getting cut off mid-way — meaning you get a **complete response in one go**, without having to ask for "continue" or follow-up chunks
- Bypasses browser limitations like output truncation or “Continue” prompts

3. Because the full text is processed in one batch, the model:
- Maintains **context**
- Keeps **style and terminology consistent**
- Produces **clean, high-quality translations**, even with long content

The downside is that you need to manually copy the original text and paste it into the Python script, then after the translation is received, you have to copy the translated text and save it separately. This process isn’t fully automated but helps maintain translation quality for long texts.

4. I’m currently using **DeepSeek models** via the **chutes.ai server**, which hosts high-performance open-source models.

5. I’m aware of the newly released **DeepSeek-TNG-R1T2-Chimera** (July 2025), which combines the strengths of several DeepSeek variants. I haven’t used it yet, but it's worth checking out if you're into model testing and optimization.


### TL;DR

- **It’s not about how long the text is**, it’s how you send it and which model you use.
- With a proper script and models like **DeepSeek**, long texts can be translated **consistently and accurately**.
- If users are only using browser-based interfaces and relying on "Continue" commands, **inconsistencies are expected**.

Can you elaborate on how you send **hundreds of lines of text** in one request. I tried it using my local llm and it was very hard to tune. And how to get response in json format for example with translation result for each sent line. I tried to specifically tune it to get response in json format but lm couldn't format it right

 

[ripno]

Can you elaborate on how you send **hundreds of lines of text** in one request. I tried it using my local llm and it was very hard to tune. And how to get response in json format for example with translation result for each sent line. I tried to specifically tune it to get response in json format but lm couldn't format it right

Just to clarify how I’m working: I don’t use batch systems like Translator++. I use a Python script that mimics chat-like behavior—but instead of sending requests one by one, I make requests directly to chutes.ai through the script (not a local LLM), submitting larger segments of text in one go.

Unlike browser chat UIs that enforce token limits and often cut off responses mid-output—requiring users to type something like “continue from [specific text]”—my script avoids that problem entirely.

Since the request goes through Python and not a browser, I’m able to send far more tokens in a single call, and the model receives everything as one complete context. That results in a full response—clean and continuous—without needing any follow-up prompts.

I use this method to translate Tyrano-engine visual novels, but this doesn’t mean it’s an automated batch workflow like in Translator++. I still manually extract the script using a Python script, feed it into the request, then manually handle the output before injecting it back via the script again.

It’s not fully automated, but this semi-manual workflow gives me much better control over translation consistency, terminology, and context—especially when working with long-form VN scripts.

 

[Hero_Protagonist]

Just to clarify how I’m working: I don’t use batch systems like Translator++. I use a Python script that mimics chat-like behavior—but instead of sending requests one by one, I make requests directly to chutes.ai through the script (not a local LLM), submitting larger segments of text in one go.

Unlike browser chat UIs that enforce token limits and often cut off responses mid-output—requiring users to type something like “continue from [specific text]”—my script avoids that problem entirely.

Since the request goes through Python and not a browser, I’m able to send far more tokens in a single call, and the model receives everything as one complete context. That results in a full response—clean and continuous—without needing any follow-up prompts.

I use this method to translate Tyrano-engine visual novels, but this doesn’t mean it’s an automated batch workflow like in Translator++. I still manually extract the script using a Python script, feed it into the request, then manually handle the output before injecting it back via the script again.

It’s not fully automated, but this semi-manual workflow gives me much better control over translation consistency, terminology, and context—especially when working with long-form VN scripts.

I am also using python script for sending requests. I use T++ to extract csv files and then use python script to translate them. But i do it line by line from all csvs. I am interested in details how to setup llm to translate a bunch of strings instead of line by line. Maybe my local 8b lm is too weak for that and if i try deepseek from chutes.ai it ll work better

 

[ripno]

I am also using python script for sending requests. I use T++ to extract csv files and then use python script to translate them. But i do it line by line from all csvs. I am interested in details how to setup llm to translate a bunch of strings instead of line by line. Maybe my local 8b lm is too weak for that and if i try deepseek from chutes.ai it ll work better

Python Chatbot for Multi-Line Translation (Stateless & Configurable)

I'm sharing a Python script designed to send multi-line text requests to an AI server without storing conversation history. The folder structure is simple:

chatbot_project/
├── chatbot.py
├── run_chatbot.bat
├── setup.py
├── run setup.bat
├── venv/
└── configs/
　　　├── 01 ChatGPT 3.5 Turbo.txt
　　　├── 02 DeepSeek V3 0324.txt
　　　└── 03 Mistral Local.txt

Each `.txt` file inside `configs/` contains settings like the following example:

BASE_URL = "

You must be registered to see the links

"
MODEL = "deepseek-ai/DeepSeek-V3-0324"
API_KEY = "your-api-key"
SERVER_TYPE = "openai"

TEMPERATURE = 0.6
MAX_TOKENS = 8000
ENABLED = false
PROMPT = "You are a professional translator."

Key Features of `chatbot.py`:
- ✅ Supports multi-line input via terminal (note: you can't edit previously entered lines during input)
- ✅ Displays streaming responses as the AI types
- ✅ Stateless: does not retain history, ideal for long-form translations like VN scripts (the AI does not remember past exchanges)
- ✅ Only one AI will be used at a time—the first config file with `ENABLED = true` (based on filename order)
- ✅ You can add support for local servers like Ollama by changing the `BASE_URL` (never tested though, I personally have only used Chutes.ai so far)
- ✅ AI profile files are **fully customizable** — you can rename them, add new ones, or delete existing profiles at any time. As long as the format remains consistent, the script will work without any code changes.


Note: This project uses a virtual environment (`venv`).
Make sure to activate the environment before running the scripts,
unless you're running `setup.py`, which handles that automatically.

⚠ If you move this project to a different folder or copy it to another computer,
you'll need to reactivate or recreate the virtual environment.
In some cases, the existing `venv/` may not work due to absolute path references
tied to the original system.

To fix this, it's recommended to delete the existing `venv/` folder
and re-run `setup.py` or `run setup.bat` with working internet connection, which will recreate the environment
and install the necessary dependencies.

I also wrote a separate **Python script for counting tokens** in `.txt` files. It only needs an internet connection once to install the tokenizer library (like `tiktoken`) and can then be used completely offline. Very useful when you're working with long scripts and want to check if your input fits within a model’s token limit.

I'm not a programmer — this entire project was built with help from ChatGPT and Copilot as part of a hands-on learning process. If anyone would like to try it or wants the complete scripts (`chatbot.py` and the token counter), I’d be happy to share them.

If you encounter any issues, I kindly ask for your understanding.

 

[Hero_Protagonist]

Python Chatbot for Multi-Line Translation (Stateless & Configurable)

I'm sharing a Python script designed to send multi-line text requests to an AI server without storing conversation history. The folder structure is simple:

chatbot_project/
├── chatbot.py
├── run_chatbot.bat
├── setup.py
├── run setup.bat
├── venv/
└── configs/
　　　├── 01 ChatGPT 3.5 Turbo.txt
　　　├── 02 DeepSeek V3 0324.txt
　　　└── 03 Mistral Local.txt

Each `.txt` file inside `configs/` contains settings like the following example:

BASE_URL = "

You must be registered to see the links

"
MODEL = "deepseek-ai/DeepSeek-V3-0324"
API_KEY = "your-api-key"
SERVER_TYPE = "openai"

TEMPERATURE = 0.6
MAX_TOKENS = 8000
ENABLED = false
PROMPT = "You are a professional translator."

Key Features of `chatbot.py`:
- ✅ Supports multi-line input via terminal (note: you can't edit previously entered lines during input)
- ✅ Displays streaming responses as the AI types
- ✅ Stateless: does not retain history, ideal for long-form translations like VN scripts (the AI does not remember past exchanges)
- ✅ Only one AI will be used at a time—the first config file with `ENABLED = true` (based on filename order)
- ✅ You can add support for local servers like Ollama by changing the `BASE_URL` (never tested though, I personally have only used Chutes.ai so far)
- ✅ AI profile files are **fully customizable** — you can rename them, add new ones, or delete existing profiles at any time. As long as the format remains consistent, the script will work without any code changes.


Note: This project uses a virtual environment (`venv`).
Make sure to activate the environment before running the scripts,
unless you're running `setup.py`, which handles that automatically.

⚠ If you move this project to a different folder or copy it to another computer,
you'll need to reactivate or recreate the virtual environment.
In some cases, the existing `venv/` may not work due to absolute path references
tied to the original system.

To fix this, it's recommended to delete the existing `venv/` folder
and re-run `setup.py` or `run setup.bat` with working internet connection, which will recreate the environment
and install the necessary dependencies.

I also wrote a separate **Python script for counting tokens** in `.txt` files. It only needs an internet connection once to install the tokenizer library (like `tiktoken`) and can then be used completely offline. Very useful when you're working with long scripts and want to check if your input fits within a model’s token limit.

I'm not a programmer — this entire project was built with help from ChatGPT and Copilot as part of a hands-on learning process. If anyone would like to try it or wants the complete scripts (`chatbot.py` and the token counter), I’d be happy to share them.

If you encounter any issues, I kindly ask for your understanding.

Thank you, I'll test it. I read tokenizer code, I wrote it much simplier - rough estimate: 4 characters per token for English and 2 characters per token for Japanese:
def estimate_tokens(text):
return len(text) // 2 if any(ord(c) > 127 for c in text) else len(text) // 4
I think this estimation is close enough and we don't need to count the exact number of tokens. Well maybe you need the exact number if you wanna check your input but this estimate will get you like 1-2% margin of error so it is not so bad

 

[Hero_Protagonist]

Python Chatbot for Multi-Line Translation (Stateless & Configurable)

I'm sharing a Python script designed to send multi-line text requests to an AI server without storing conversation history. The folder structure is simple:

chatbot_project/
├── chatbot.py
├── run_chatbot.bat
├── setup.py
├── run setup.bat
├── venv/
└── configs/
　　　├── 01 ChatGPT 3.5 Turbo.txt
　　　├── 02 DeepSeek V3 0324.txt
　　　└── 03 Mistral Local.txt

Each `.txt` file inside `configs/` contains settings like the following example:

BASE_URL = "

You must be registered to see the links

"
MODEL = "deepseek-ai/DeepSeek-V3-0324"
API_KEY = "your-api-key"
SERVER_TYPE = "openai"

TEMPERATURE = 0.6
MAX_TOKENS = 8000
ENABLED = false
PROMPT = "You are a professional translator."

Key Features of `chatbot.py`:
- ✅ Supports multi-line input via terminal (note: you can't edit previously entered lines during input)
- ✅ Displays streaming responses as the AI types
- ✅ Stateless: does not retain history, ideal for long-form translations like VN scripts (the AI does not remember past exchanges)
- ✅ Only one AI will be used at a time—the first config file with `ENABLED = true` (based on filename order)
- ✅ You can add support for local servers like Ollama by changing the `BASE_URL` (never tested though, I personally have only used Chutes.ai so far)
- ✅ AI profile files are **fully customizable** — you can rename them, add new ones, or delete existing profiles at any time. As long as the format remains consistent, the script will work without any code changes.


Note: This project uses a virtual environment (`venv`).
Make sure to activate the environment before running the scripts,
unless you're running `setup.py`, which handles that automatically.

⚠ If you move this project to a different folder or copy it to another computer,
you'll need to reactivate or recreate the virtual environment.
In some cases, the existing `venv/` may not work due to absolute path references
tied to the original system.

To fix this, it's recommended to delete the existing `venv/` folder
and re-run `setup.py` or `run setup.bat` with working internet connection, which will recreate the environment
and install the necessary dependencies.

I also wrote a separate **Python script for counting tokens** in `.txt` files. It only needs an internet connection once to install the tokenizer library (like `tiktoken`) and can then be used completely offline. Very useful when you're working with long scripts and want to check if your input fits within a model’s token limit.

I'm not a programmer — this entire project was built with help from ChatGPT and Copilot as part of a hands-on learning process. If anyone would like to try it or wants the complete scripts (`chatbot.py` and the token counter), I’d be happy to share them.

If you encounter any issues, I kindly ask for your understanding.

I tested it and all i got was 402 error message Payment Required. Read reddit post and apparently many users abused free tier by creating multiple accounts. So to use free api you have to deposit at least $5

 

[ripno]

I tested it and all i got was 402 error message Payment Required. Read reddit post and apparently many users abused free tier by creating multiple accounts. So to use free api you have to deposit at least $5

Hi, I just want to ask—what AI model and server are you using? If you're using a ChatGPT account, I assume that requires a subscription, right?

Personally, I’m using free services like Chutes.ai. . You just need to register—no subscription needed. After registering, you’ll even get a free API key, just like I did. It's been quite handy for my translation work.