Dolphin ai Troubleshooting: Common API Integration Mistakes

Assuming 'uncensored' means 'no filters at all'

Uncensored does not mean the model has no limits. It specifically means the model will not refuse lawful adult, controversial, or creative topics that standard models might block. Our uncensored LLM accepts any prompt without moralizing, but it still enforces a hard content limit regarding minors.

For example, if you request sexual content involving minors, the API will return a refusal regardless of the uncensored setting. This is a hard rule applied at the inference layer. All other lawful adult content, including explicit fiction or nuanced debate, passes through without soft filters.

Confusing context window with max output tokens

The context window is 100,000 tokens, but the maximum output per request is 16,000 tokens. This distinction is critical for long-document generation. If you send a 90k token prompt and ask for 30k tokens, the request fails or truncates unexpectedly.

• Max context: 100,000 tokens (input + output combined).
• Max output: 16,000 tokens per request.
• Default output: 2,048 tokens if max_tokens is unset.

Always set max_tokens explicitly in your API calls. This prevents runaway token usage and ensures predictable billing. Errors that exceed these limits do not consume credit, but they break your parsing logic.

Ignoring streaming responses in async environments

Our API supports streaming via Server-Sent Events (SSE). If you use a synchronous client for a long generation, you will hit timeout limits. Async environments expect a stream of partial chunks, not a single massive payload.

Each chunk contains token usage data in the final payload. This allows you to track real-time costs. Without streaming, your UI may freeze for several seconds during heavy generation. Use the

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell the story in second person."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

block to see the correct client-side handling.

Setting the wrong model ID in the request body

Many developers default to "gpt-3.5-turbo" or "gpt-4". Our API requires the model ID to be exactly "uncensored". Sending any other ID results in a 404 or model-not-found error. This is not a vendor-specific model like GPT or Claude.

It is an open-weight model running on our infrastructure. Ensure your SDK configuration points to HTTPS://api.dolphinmodelai.com/v1 and uses "uncensored" as the model name. This is the only model we serve.

Forgetting to handle tool_choice and function calling formats

Function calling is supported, but the format must match OpenAI standards. You must specify tool_choice explicitly if you want forced tool usage. The API accepts tools, tool_choice, and the standard message formats.

Incorrectly formatted tool definitions lead to parsing errors on the client side. Ensure your JSON schemas are valid. The model returns structured JSON that your code must parse. Use the

Copyimport OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.dolphinmodelai.com/v1", apiKey: process.env.API_KEY });

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Draft a villain monologue for my game." }],
});
console.log(resp.choices[0].message.content);

block for an example of tool definition.

Misunderstanding the difference between input and output pricing

Input tokens cost $0.15 per 1M tokens. Output tokens cost $0.50 per 1M tokens. Output is four times more expensive than input. This ratio is standard for most LLM APIs but affects your budget significantly.

Prepaid credit is charged by real token usage. Errors and refusals are free. If you send a 10k token prompt and get a 10k token response, you pay for both. Crypto top-ups are required. You can top up with USDT on TRC20 or USDC on Base. The minimum top-up is $20. Bonuses apply at $50 (+5%), $100 (+10%), and $200 (+15%).

Not checking the response format for JSON mode errors

JSON mode requires you to set response_format to {"type": "json_object"}. Without this, the model may return markdown or text that breaks your parser. This is a common source of integration failures.

Ensure your schema is strict. The model does not guarantee perfect JSON if the schema is ambiguous. Use the

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.dolphinmodelai.com/v1", api_key="YOUR_KEY")

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Summarise this thread without softening it."}],
)
print(resp.choices[0].message.content)

block to see how to enforce JSON output. This reduces post-processing overhead.

Assuming all OpenAI SDK parameters work identically

Parameters like temperature, top_p, stop, seed, presence_penalty, and frequency_penalty work similarly to OpenAI. However, not all edge-case parameters are supported. We support the core set required for most use cases.

Streaming, function calling, and JSON mode are fully supported. Check the

Copycurl https://api.dolphinmodelai.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Run unit tests for the payment module"}]
  }'

block for a basic request. Avoid assuming unsupported parameters will be ignored gracefully. They may cause errors.

Overlooking the 8MB request body limit

The maximum request body size is 8 MB. If you send large files or extensive context, you may exceed this limit. This is a hard constraint on the API gateway. Requests exceeding this size are rejected immediately.

Ensure your payload is compressed or truncated. Use the

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell the story in second person."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

example to see how to handle large contexts efficiently. This limit applies to the entire request, including headers and body.