The choice in one table
| You need | Better fit |
|---|---|
| Image, audio or video input or output | A multimodal family such as Gemini (verify the exact models on Google's docs) |
| Different tiers for cheap and hard tasks | A model family with several sizes |
| One model, one price, nothing to select | A single-model endpoint |
| Answers without content refusals for lawful adult use | This API |
| Embeddings or fine-tuning | Another service. This API has neither |
We do not list Google's models, context sizes or prices here, since they change and Google documents them better than we can. Read its current model list before you decide anything about the Gemini side.
What a lineup gives you
A family of models, as offered by most large vendors, usually spans sizes and speeds. You route easy tasks to a small, cheap model and hard ones to a larger model. You pay more where quality matters and less where it does not. Some models in a family accept images, audio or video, which opens uses a text-only API cannot cover.
That flexibility has a cost in engineering. You decide the routing rules. You track which model version each feature uses, because behavior changes when a version changes. You handle different limits and prices per model, and you test your prompts on each.
What one model gives you
This site serves one open-weight model, ID uncensored, operated by an independent provider and tuned to answer without content refusals for lawful adult use. It is not a Google product or the official API of any vendor, and it is not a router across vendors. There is a hard limit: no sexual content involving minors.
The simplicity is real:
- One model ID in every request. No selection logic.
- One price: $0.15 per 1M input tokens and $0.50 per 1M output tokens.
- One context size: 100,000 tokens, prompt plus completion. Completion can use whatever the prompt leaves, and
max_tokensis optional. - One set of limits: 8 concurrent requests and 300 per minute on a full key.
The trade is equally real. You cannot send an image. You cannot move a cheap task to a smaller model, because there is none. If this model is wrong for a task, the answer is another service for that task.
See the model list yourself
The endpoint implements GET /v1/models, so any client that lists models works. Expect a very short list.
curl https://api.googlegeminiuncensored.com/v1/models -H "Authorization: Bearer $API_KEY"In Python, the same call with the OpenAI SDK:
from openai import OpenAI
client = OpenAI(base_url="https://api.googlegeminiuncensored.com/v1", api_key="YOUR_KEY")
for m in client.models.list():
print(m.id)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "List three trade-offs of using one model for everything."}],
)
print(resp.choices[0].message.content)You can also call POST /v1/responses if your code uses that style. Streaming, tool calling and JSON mode (response_format with json_object) work as in the OpenAI API, and sampling parameters such as temperature, top_p, stop, seed and the penalties are passed through.
If you want both: a small router
Nothing forces an either-or choice. Many teams send multimodal or specialist requests to one provider and plain text generation to another. The router below picks a client by task type. The branch for images is left as a stub, since this API does not accept them.
from openai import OpenAI
text_client = OpenAI(base_url="https://api.googlegeminiuncensored.com/v1", api_key="YOUR_KEY")
def route(task, payload):
if task == "vision":
raise NotImplementedError("send image tasks to a multimodal provider")
resp = text_client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": payload}],
)
return resp.choices[0].message.content
print(route("text", "Write a two-line product blurb for a note-taking app."))Keep the routing rule in one place and log which branch handled each request. When prices or quality shift, you change one function and compare the logs.
Price comparison without made-up numbers
A fair price comparison needs the current rates of the other side, which you can read on Google's pricing page. Then run both through the same formula: input tokens divided by a million, times the input rate, plus output tokens divided by a million, times the output rate.
For this API, a request with 20,000 input tokens and 1,000 output tokens costs 0.02 x 0.15 + 0.001 x 0.50 = $0.003 + $0.0005 = $0.0035. A job of 1,000 such requests costs $3.50. A model family often has a cheaper small tier and a pricier large tier, so compare your actual task against the tier you would really use, not against the average.
Failed or refused requests are not charged here, credit never expires, and there is no subscription. Top-ups are any whole amount from $20 to $500 with bonuses of +5% from $50, +10% from $100 and +15% from $200, paid in USDT on TRC20 or USDC on Base. See the pricing page for details.
Version drift and why it matters
In a model family, versions get updated, renamed and retired over time, and each change can alter output style, length and refusal behavior. Your prompts that worked last quarter may need new tuning. The cure is a regression set of prompts with expected traits, run whenever the model behind a name changes.
A single-model endpoint has the same risk in principle, since any hosted model can be updated by its operator. The difference is scope: one model means one thing to retest, not a matrix of tiers. Whichever route you choose, pin what you can, log the model ID with every request, and keep your test prompts under version control.
Last, avoid choosing on a leaderboard score alone. Public rankings test general skills, and your product tests a narrow slice. Twenty of your own prompts tell you more than a table of numbers, and with the $0.50 trial the experiment costs nothing to start.
What 100,000 tokens of context holds
The context window on this API is 100,000 tokens, shared by the prompt and the completion. As a rough rule of thumb for English text, a token is about three quarters of a word, so the window fits on the order of 70,000 words. That covers a long contract, a medium codebase module set, or a very long chat history. It does not cover a whole book series or a large repository.
A request that fills the window with 100,000 input tokens costs 0.1 x 0.15 = $0.015 for input. Add a 2,000-token answer at 0.002 x 0.50 = $0.001 and the call is $0.016. Even full-window calls are cheap one at a time, and expensive only when you send thousands of them, so reuse results where you can.
Compare context sizes by checking each model's documentation for the exact figure, since a family may include models with larger or smaller windows. If a task needs more than 100,000 tokens, split it, summarize in stages, or use a model with a bigger window.
How to decide
- List your tasks and mark which need non-text input. If any do, you need a multimodal provider for those.
- For the text tasks, run 20 representative prompts through both options and compare output quality, refusals and cost.
- Check limits against your peak traffic. Here a trial key allows 2 concurrent requests and 60 per minute; a full key allows 8 and 300.
- Decide whether you want routing flexibility or a fixed behavior. Fixed behavior means fewer surprises when versions change.
You can run step two cheaply. After sign-up with Google or email and password, claim $0.50 of trial credit on the API key page. It is valid for 7 days, needs no card, and is one per person. For request details see the docs, and for background on unfiltered models read the uncensored AI developer's guide.
