Quickstart: DeepSeek Coder API Integration

Base URL and Authentication

Your API key authenticates every request to our hosted endpoint. Use the base URL https://api.coderdeepseek.cc/v1 with any OpenAI SDK or HTTP client. The model identifier is strictly uncensored. This runs on our own servers and is not a resell of another vendor's model. You receive an immediate API key upon signup via Google or email. Keep this key secure as it controls your prepaid credit.

Authentication relies on the Authorization header. Pass your key as a Bearer token. Every request must include this header to avoid a 401 error. We do not use query parameters for authentication. This ensures clean headers and compatibility with standard middleware.

Sending Requests: Chat Completions

The chat completions endpoint processes your prompts and returns text outputs. Send a POST request to /v1/chat/completions. Include the model name, messages array, and your desired parameters. The system processes text in and returns text out. You can control the response format and stopping criteria. This works for both simple queries and complex coding tasks.

Use the following curl command to test your connection. Replace YOUR_API_KEY with your actual key. The request uses the uncensored model identifier. This confirms your authentication and credit balance are active.

Copycurl https://api.coderdeepseek.cc/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "what is the current version of the library"}]
  }'

Verify the response contains the choices array. Each choice includes a message with the generated content. Check the usage object for token counts. This helps you monitor your spending accurately.

Python SDK Integration

Integrate the API into your Python projects using the official OpenAI package. Set the base URL to our endpoint. Initialize the client with your API key. This allows you to use familiar methods like chat.completions.create. The SDK handles JSON serialization and HTTP requests automatically.

Configure the model to uncensored. Pass your messages in the standard format. The SDK supports all our features including function calling and JSON mode. You can set parameters like temperature and top_p directly. This makes migration from other providers straightforward.

Copyfrom openai import OpenAI

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

Handle exceptions for network errors or invalid requests. Check the status code if you parse the raw response. This ensures robust error handling in your application. The SDK abstracts most of the complexity away.

Node SDK Integration

Use the Node.js OpenAI SDK to integrate with your JavaScript or TypeScript projects. Install the package and configure the base URL. This maintains compatibility with your existing code structure. You can use the same methods as in Python. The SDK supports both CommonJS and ES modules.

Set the model to uncensored. Pass your messages and parameters. The SDK handles streaming and non-streaming requests. You can catch errors and log them appropriately. This ensures your application remains stable under load.

Copyimport OpenAI from "openai";

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

Test your integration with a simple prompt. Verify the response matches your expectations. Check the token usage in the response object. This helps you track costs and performance. The SDK makes it easy to iterate quickly.

Streaming Responses and Token Usage

Enable streaming by setting stream: true in your request. The API returns a Server-Sent Events (SSE) stream. You receive chunks of text as they are generated. This reduces perceived latency for long responses. The final chunk contains the total token usage.

Parse the SSE events to extract the content. Concatenate the chunks to form the complete response. Monitor the usage object in the last chunk. This gives you accurate token counts for billing. Streaming is ideal for real-time applications.

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)

Handle network interruptions gracefully. Reconnect if the stream drops. The API does not resend previous chunks. You must reconstruct the full text on the client side. This provides a smooth user experience.

Limits, Errors, and Context Window

Our API enforces strict limits to ensure stability. You can make 300 requests per minute per key. Up to 8 requests can run simultaneously. The request body must not exceed 8 MB. Exceeding these limits results in a 429 rate limit error. Handle these errors with exponential backoff.

The context window is 100,000 tokens. This includes both the prompt and the completion. Max output is 16,000 tokens per request. If you do not set max_tokens, it defaults to 2,048. A 401 error means your key is invalid. A 402 error means you have no credit. Top up via crypto to continue using the service.