Integrate the DeepSeek Unchained API

Authentication and Base URL Setup

Use your API key with the base URL HTTPS://api.deepseekunchained.com/v1. This endpoint works with official OpenAI SDKs and any OpenAI-compatible client. Get your key by signing up with Google or email. The key is shown immediately on the Get API key page. No phone number is required for signup. Your prompts are not used for training. Privacy is maintained without extra steps. You only need an email address to create an account. The key grants access to the chat-completions endpoint. It does not grant access to embeddings or image generation. Keep your key secure. Rotate it if needed via the dashboard. A new key replaces the old one immediately. One active key per account is allowed. Errors and refusals do not consume credit. This ensures you only pay for actual tokens consumed.

Chat Completions Endpoint (POST)

Send text in and get text out using POST /v1/chat/completions. This endpoint accepts a JSON body with a messages array. Each message has a role and content field. The system role sets the behavior. The user role provides the prompt. The model field must be set to "uncensored". This model is tuned for compliance over corporate filters. It answers directly without lectures. You can set temperature and top_p for creativity. Stop sequences halt generation early. Presence and frequency penalties adjust repetition. The response includes usage statistics. These stats show input and output token counts. Errors return standard HTTP status codes. A 401 means an invalid key. A 402 means no credit. A 429 means rate limit exceeded.

Streaming Responses with SSE

Enable streaming by setting stream to true in the request body. The API returns Server-Sent Events (SSE). Each chunk contains partial text content. This allows real-time display of responses. The final chunk includes token usage data. This data shows total tokens consumed. Streaming reduces perceived latency for users. It is ideal for chat interfaces. The SDK handles chunk parsing automatically. You do not need to manage SSE manually. The model supports full streaming. Parameters like temperature work normally. Stop sequences still trigger end events. Errors are sent as SSE events too. This ensures robust error handling. Use streaming for better user experience. It keeps the connection open until complete.

Function Calling and Tool Use

Define tools in the request body for function calling. The model returns tool calls in the response. These calls include function names and arguments. Your code executes the function and sends results back. The model uses results to generate final text. This enables agent-like behavior. You can define multiple tools. The model chooses which to use. Tool choice can be forced or auto. Auto lets the model decide. Forced mode requires a specific tool. This is useful for structured workflows. Arguments are returned as strings. Parse them as JSON in your code. The model supports complex tool definitions. Use this for API integrations. It extends the model's capabilities. Errors in tool execution are handled by your code. The model retries if needed.

JSON Mode for Structured Output

Force JSON output by setting response_format to json_object. The model returns valid JSON strings. This is ideal for programmatic consumption. No parsing errors occur. The output is strictly formatted. Use this for data extraction tasks. The model follows schema hints. Define properties in your prompt. The model respects these constraints. Temperature affects JSON validity. Lower values ensure consistency. Use this for reliable data pipelines. Streaming works with JSON mode. The final chunk contains the complete object. Token usage is reported accurately. Errors are returned as standard JSON. This ensures easy error handling. Use JSON mode for APIs. It reduces post-processing overhead. The model is optimized for this format.

Rate Limits and Request Constraints

Limit is 300 requests per minute per key. You can send 8 requests simultaneously. Request body size maxes at 8 MB. Context window is 100,000 tokens total. This includes prompt and completion. Max output is 16,000 tokens per request. Set max_tokens to control length. Default is 2,048 if not set. Rate limits are enforced strictly. Exceeding them returns a 429 error. No credit is consumed during 429s. Errors do not consume credit. This protects your balance. Requests are queued if limits are hit. Wait and retry after a delay. Use exponential backoff for robustness. Monitor your usage via the dashboard. Credit never expires. Top up with crypto only. USDT or USDC on Base. Bonus credit applies on top-ups.

cURL

Copycurl https://api.deepseekunchained.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "list ten open source libraries for rust async io"}]
  }'

Python

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.deepseekunchained.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)

Node.js

Copyimport OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.deepseekunchained.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);

Streaming

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)