API Documentation & Quickstart

Base URL and Authentication

Use the provided endpoint to route requests to our uncensored inference engine. Replace the standard OpenAI base URL with our specific domain to ensure your calls reach the correct server.

Authentication relies on a single API key generated during signup. Pass this key in the Authorization header as a Bearer token. The system validates this key against your account limits and credit balance before processing.

No complex OAuth flows or temporary tokens are required. Your key remains valid until you revoke or replace it. We support standard OpenAI SDKs directly, meaning you only need to update the client configuration.

• Base URL: https://api.apideepseek.cc/v1
• Auth Header: Authorization: Bearer YOUR_API_KEY

First Request

Send your first completion by posting a message to the chat endpoint. This simple call verifies your key and returns an uncensored response from the model.

The request body requires a model identifier and a messages array. The model ID is always uncensored. You can control behavior using parameters like temperature and top_p. The server returns the generated text in the choices array.

Errors such as 401 indicate an invalid key, while 402 means you need to top up your crypto credit. Use the following cURL command to test connectivity.

Python SDK Integration

Integrate the API into your Python projects by updating the OpenAI client configuration. This approach allows you to use familiar methods while pointing to our servers.

Set the base_url and api_key attributes on the client instance. This ensures all subsequent calls use our uncensored model. You can pass standard parameters like max_tokens to control output length.

The response object contains the generated content in response.choices[0].message.content. This method works seamlessly with existing codebases that expect OpenAI-compatible behavior.

Node SDK Usage

Configure the Node.js OpenAI package to use our base URL. This enables direct integration with your JavaScript or TypeScript applications.

Initialize the client with your API key and the custom base URL. The chat.completions.create method works identically to the standard implementation. You receive a standard response object containing the generated text.

This setup allows you to maintain your existing project structure while benefiting from our uncensored model. The SDK handles serialization and error parsing automatically.

Streaming Responses with SSE

Enable real-time token generation by setting stream to true. The server sends a series of Server-Sent Events (SSE) instead of a single response.

Each event contains a partial chunk of the generated text. You can accumulate these chunks to display the response as it generates. The final chunk includes the token usage statistics.

This approach reduces perceived latency for users. It is ideal for chat interfaces where immediate feedback is crucial. Handle the data events to parse the JSON chunks.

Limits, Errors, and Context Window

Your account is subject to strict rate limits and a large context window. You can send 300 requests per minute and have 8 concurrent requests active per key. The context window supports 100,000 tokens total, including prompt and completion.

Max output is 16,000 tokens per request. If you do not specify max_tokens, the limit defaults to 2,048. Errors return standard HTTP codes: 401 for invalid keys, 402 for insufficient credit, and 429 for rate limits.

Paid credit never expires, but mistakes like double charges are fixed via Support. Refunds are not issued for used credit. The hard content limit refuses requests involving minors.

cURL

Copycurl https://api.apideepseek.cc/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "What is the latency for this endpoint"}]
  }'

Python

Copyfrom openai import OpenAI

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

Node.js

Copyimport OpenAI from "openai";

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

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)