Groq API models vs a hosted uncensored model

Groq and Grok are not the same thing

Groq (with a q) is a company that runs open-weight language models on its own inference hardware and sells access through GroqCloud. Grok (with a k) is the name xAI gives to its chatbot and models. Two products, two vendors, one letter of difference, which is why searches mix them up.

We are neither. Our service is an independent OpenAI-compatible endpoint for one open-weight model tuned to answer without content refusals for lawful adult use. It is not the official API of xAI, Groq or any other vendor, and it is not a router across vendors.

How to read any model list

A provider's model list is a table of choices, and each row hides the same few questions. Ask them in this order.

• Who trained the model? A host that serves open-weight models from several labs gives you many families under one key. A lab serving its own models gives you one family.
• What is the context window? This sets how much history, code or document text fits in one call.
• What are the input and output rates? Both matter, and output is usually the larger one per token.
• What are the rate limits? Requests per minute and concurrent requests decide whether a batch job takes minutes or hours.
• What does the usage policy allow? Every provider publishes one. Read it before building around a model.

We do not copy Groq's catalog here because it changes, and a stale list is worse than none. Fetch it live from their models endpoint with your own key, and treat their docs as the source of truth.

What this API lists

Our list is short on purpose. GET /v1/models returns the one model you can call, with the ID uncensored.

Copycurl https://api.grockapi.com/v1/models   -H "Authorization: Bearer YOUR_KEY"

That single model has a 100,000-token context window shared by prompt and completion, supports streaming, tool calling and JSON mode, and accepts temperature, top_p, stop, seed and the penalties. It is text only: no images, audio, embeddings or fine-tuning.

One model means no decision about which one to call. It also means no cheaper small variant for easy jobs and no specialist for code or vision. If you need that range, a multi-model host is the better fit, and we say so plainly.

What one model means in practice

With a single model there is nothing to route. You do not pick between a small fast model and a large slow one, and you do not need a fallback table in your config. Every request goes to the same model, so behavior is easy to reason about: if a prompt works today, it should keep working on the same settings. You can pin seed and temperature for repeatable tests.

The trade-off is cost control by model choice. On a multi-model host, you can send easy classification jobs to a small model and save money. Here you control cost by prompt length and by max_tokens, at $0.15 per 1M input and $0.50 per 1M output tokens.

Naming pitfalls in code and in search

The near-identical names cause real bugs, and they also skew search results. A few to watch for:

• Keys are not interchangeable. A key issued by one provider only works at that provider's base URL. Sending it elsewhere returns an authorization error, and it also leaks a secret to a host that has no business seeing it.
• Environment variables. Name them after the provider, such as GROQ_API_KEY and UNCENSORED_KEY, never a generic API_KEY shared across projects.
• Model IDs differ. A model name that works at one host is rejected at another. Always pass the ID from that host's own models list.
• Search terms. Searching for the model list of a provider gives results about that provider only. Add the company name, because a similar-sounding word pulls in the wrong provider.

If a request fails with a 401 or a model-not-found error right after you copied a snippet, check the base URL, key and model name together. In nearly every case, one of the three belongs to a different provider.

Side-by-side comparison

Question	Groq	Grok (xAI)	This API
What it is	Inference host for open-weight models	xAI's own model family	Hosted open-weight model, one ID
Model choice	Several, per their catalog	Several, per xAI docs	One: uncensored
OpenAI-style client	Documented as compatible	Documented as compatible	Yes, change base URL and key
Prices	Check their current pricing	Check their current pricing	$0.15 in, $0.50 out per 1M
Content policy	Provider policy applies	Provider policy applies	No content refusals for lawful adult use

Pick the row that matters most for your project. If breadth of models matters, look at a multi-model host. If a particular vendor's model matters, go to that vendor. If refusals are what blocks your product, the last column is the relevant one.

Using more than one provider in the same app

Because all three speak a chat-completions style API, you can keep a small client per provider and route by task. Here is the pattern with two clients, one for this endpoint and one for whichever host you pick, with its base URL and key taken from the environment.

Copyimport os
from openai import OpenAI

adult_fiction = OpenAI(base_url="https://api.grockapi.com/v1",
                       api_key=os.environ["UNCENSORED_KEY"])
general = OpenAI(base_url=os.environ["OTHER_BASE_URL"],
                 api_key=os.environ["OTHER_KEY"])

def ask(task, prompt):
    if task == "fiction":
        client, model = adult_fiction, "uncensored"
    else:
        client, model = general, os.environ["OTHER_MODEL"]
    r = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}])
    return r.choices[0].message.content

This keeps your code independent of any one vendor. Swapping a provider later means changing three environment variables, not rewriting calls.

A fair way to test any model

Model lists tell you what exists. Only your own prompts tell you what works. A small evaluation takes under an hour.

1. Collect 30 real prompts from your product, including a few difficult ones.
2. Run each prompt against every candidate with the same settings.
3. Read the answers side by side and score each as pass, partial or fail.
4. Count refusals separately, since they matter more than style for some products.
5. Record tokens used and compute cost per 100 prompts.

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.grockapi.com/v1", api_key="YOUR_KEY")
prompts = json.load(open("prompts.json"))   # a list of strings

results = []
for p in prompts:
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": p}],
        temperature=0.7,
    )
    results.append({"prompt": p,
                    "answer": r.choices[0].message.content,
                    "in": r.usage.prompt_tokens,
                    "out": r.usage.completion_tokens})

json.dump(results, open("uncensored_results.json", "w"), indent=1)

Point the same script at another provider by changing the three values, and compare the two result files. Measure latency yourself on your own network instead of trusting a published figure, because it depends on where you run.

Which should you choose

Choose a multi-model host when you want to test several model families and pick the cheapest that passes your evaluation. Choose xAI when you specifically want Grok. Choose this endpoint when your text product is held back by refusals on lawful adult material and one model is enough.

Whatever you pick, test with real prompts before committing. The API key page gives new accounts $0.50 of trial credit valid for 7 days, no card needed. The documentation covers endpoints and limits, the pricing page lists top-up tiers, and our uncensored Grok guide explains the background. One hard limit applies on every plan: no sexual content involving minors.

A decision shortcut

• You want to compare many open-weight models cheaply: use a multi-model host and run the evaluation from the previous section.
• You want a specific vendor's flagship model: go to that vendor.
• You need image, audio or embedding endpoints: none of the text-only options here will do, so pick a service that offers them.
• You want one OpenAI-compatible text model that does not refuse lawful adult requests: start with the trial key here.

None of these choices is permanent. Because the request format is shared, switching later is a matter of base URL, key and model name.

More guides

• Grok API cost: token pricing and worked examples
• Grock uncensored: The Definitive Guide

Frequently Asked Questions

Is grock uncensored the same as Grok? No. Grock uncensored is an independent open-weight model. It is not produced by xAI or any other major vendor. It is tuned for uncensored output but runs on its own architecture.

Can I use this API for commercial projects? Yes. You can use the output for any lawful purpose. There are no restrictions on commercial use. The model does not claim ownership of your generated text.

How do I top up my credit? Go to the dashboard. Select crypto payment. Choose USDT on TRC20 or USDC on Base. Send the desired amount between $20 and $500. Credit is added immediately. Bonus credits apply automatically based on the amount.

What happens if I make a mistake? Credit is not refunded. It never expires. If you are double-charged, use the Support page to resolve the issue. The support team will review the transaction.