Dolphin AI: Production Checklist for Uncensored LLMs

Verify uncensored content policy

Yes, the model does not refuse lawful adult, fictional, security-research, or controversial topics.

Unlike standard LLMs that apply hidden safety filters, an uncensored AI model allows you to generate NSFW content or explore edge cases without unexpected refusals. You should verify this by sending a request that typically triggers a safety block in commercial models. If the response returns text instead of a refusal, the policy is working as intended. Note that a hard content limit always applies: requests involving sexual content with minors are refused. This is a standard legal boundary, not a stylistic filter.

When testing, use prompts that are technically valid but socially restricted. This confirms the model is truly uncensored for your specific use case. Remember, this applies to text generation only. There is no image or audio generation, so the uncensored capability is strictly for text.

Check context window limits

Yes, the context window supports 100,000 tokens for both prompt and completion combined.

This large window allows you to process extensive documents or long conversations in a single request. However, you must account for the max output limit. You can request up to 16,000 tokens per response. If you do not set the max_tokens parameter, the model defaults to 2,048 tokens. This distinction is critical for long-form generation tasks.

When designing your application, ensure your client library handles long responses correctly. Streaming is often necessary to manage memory usage for large outputs. The 100,000-token limit applies to the total request size. This means your input prompt and the generated output share this budget. Plan your token usage accordingly to avoid truncation or errors.

Confirm streaming support

Yes, streaming is supported via Server-Sent Events (SSE).

Streaming allows you to receive tokens as they are generated, reducing perceived latency for users. This is essential for chat interfaces and real-time applications. The API returns token usage information in the last chunk of the stream. This ensures you can track costs accurately even when streaming.

To implement this, use the stream parameter in your request. Your client library should handle the SSE stream correctly. Not all SDKs handle streaming equally well. Test your implementation to ensure it does not drop tokens or delay display. Streaming is a standard feature in modern LLM APIs. It improves user experience significantly for long responses.

Test function calling capabilities

Yes, function calling is supported with tools and tool_choice.

Function calling allows the model to output structured data that your application can execute. This is crucial for building agents or complex workflows. You define the tools in the request, and the model responds with a structured JSON object containing the function name and arguments.

Test this by defining a simple tool, such as a weather lookup or a calculator. Send a request that triggers the tool. Verify that the model outputs the correct function name and valid arguments. This confirms the model understands the tool schema. Function calling is a key feature for advanced LLM applications. Ensure your client library parses the response correctly.

Validate JSON mode stability

Yes, JSON mode is supported via the response_format parameter.

Setting response_format to json_object forces the model to output valid JSON. This is useful for parsing structured data without relying on function calling. It ensures the output is machine-readable. This feature is stable and reliable for structured data extraction.

Test this by sending a prompt that requires a specific JSON structure. Verify that the output parses correctly without errors. JSON mode is essential for integrating LLMs into existing systems. It reduces the need for post-processing to fix malformed output. Ensure your application handles JSON parsing errors gracefully.

Review pricing transparency

Yes, pricing is transparent with clear per-token billing.

The cost is $0.15 per 1 million input tokens and $0.50 per 1 million output tokens. There are no hidden fees or subscription locks. You pay only for what you use. Errors and refusals are free, which reduces risk for testing. This model is a cheap LLM API for high-volume use cases.

Prepaid credit is charged based on real token usage. The credit never expires. This is different from subscription models that charge monthly regardless of usage. You can top up anytime. The pricing is straightforward and predictable. Calculate your costs based on your expected token volume. This transparency helps you budget accurately for your projects.

Assess payment flexibility

Yes, payment is flexible but limited to crypto.

You can top up with USDT on TRC20 or USDC on Base. The minimum amount is $20, and the maximum is $500. There are bonus credits for larger top-ups: +5% from $50, +10% from $100, and +15% from $200. This allows you to test the API without commitment. Sign-up is via Google or email. The API key is shown immediately. This streamlined process reduces friction for developers. Ensure your payment gateway supports the specified cryptocurrencies. The bonus credits add value for heavy users.

Check privacy and data usage

Yes, your data is private and not used for training.

When you send a request, the prompts are not used to train the model. This is crucial for proprietary data or sensitive content. The account requires only an email address. No phone number is needed. This minimizes personal data collection. You retain full control over your data.

Verify this by checking the terms of service or API documentation. Ensure that your client library does not log prompts unnecessarily. Privacy is a key concern for enterprise users. The uncensored nature of the model means you can send sensitive content without fear of it being used for training. This is a significant advantage over commercial models that use data for improvement.

Test rate limits and concurrency

Yes, rate limits are set to 300 requests per minute and 8 concurrent requests per key.

This allows for high-throughput applications without excessive throttling. The request body limit is 8 MB. This supports large inputs. One active key is allowed per account. A new key replaces the old one. This simplifies key management.

Test your application under load to ensure it handles these limits correctly. Implement retry logic for rate limit errors. The concurrency limit is important for parallel processing. Ensure your client library respects these limits. This prevents overloading the API and ensures consistent performance. The 8 MB limit is sufficient for most use cases.