Dolphin nsfw API Documentation

Base URL and Authentication

Connect using the standard OpenAI-compatible base URL. Replace your existing API key with the one generated from your dashboard. We support any client library that accepts a base URL override.

• Base URL: https://api.dolphinnsfw.com/v1
• Auth: Bearer token in the Authorization header.

Authentication is instant. Your key works immediately after generation. No phone number is required. Sign up with Google or email. The dashboard shows your key once. Errors are free. Refusals cost nothing. This ensures you only pay for actual tokens.

First Request

Send a completion request to the chat endpoint. The model id is uncensored. It handles adult themes without refusal. Use standard JSON structures. The request body includes messages and parameters.

Here is a simple curl command to test the connection. It sends a short prompt. The response returns generated text. Check the status code for success.

Copycurl https://api.dolphinnsfw.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Generate a 500 word scene of two dolphins mating at sunset"}]
  }'

This works for any simple text generation task. You can adjust temperature and top_p. The model responds quickly. No complex setup is needed.

Python SDK Integration

Use the official OpenAI Python library. Set the base URL to our endpoint. Pass your API key. The code remains identical to standard GPT usage. This reduces integration time significantly.

Install the library. Configure the client. Send messages. The response object contains the generated text. You can access token usage from the response. This helps track costs.

Copyfrom openai import OpenAI

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

The library handles retries. It manages headers automatically. You get structured data. This approach works for both local scripts and web apps.

Node SDK Integration

Initialize the Node.js client. Point it to our base URL. Use your API key. The syntax mirrors the official documentation. This ensures consistency across languages.

Create a client instance. Define the model. Send a prompt. The response contains the content. You can parse JSON easily. This works well for server-side rendering. It also fits serverless functions.

Copyimport OpenAI from "openai";

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

The SDK handles streaming internally. You can also fetch manually. This gives you flexibility. Choose the method that fits your architecture.

Streaming and Tool Use

Enable streaming for real-time output. Set the stream parameter to true. The API sends chunks via Server-Sent Events. This reduces perceived latency. Users see text as it generates.

Function calling is supported. Define tools in the request. The model returns tool calls. You execute them. Then send results back. This enables complex workflows. JSON mode is also available. Set response_format to {"type": "json_object"}. This ensures strict output formats.

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)

Streaming works with all parameters. Temperature and top_p apply per chunk. This allows fine-tuned control. You can stop generation early. The last chunk contains total token usage.

Limits, Errors, and Context

The context window is 100,000 tokens. This includes prompt and completion. Max output is 16,000 tokens. Request body size is 8 MB. Rate limits are 300 requests per minute. Concurrency is 8 requests per key.

Handle errors gracefully. A 401 error means an invalid key. A 402 error indicates no credit. A 429 error signals rate limiting. These are standard HTTP codes. Your client should retry or notify the user.

Pricing is transparent. Input tokens cost $0.15 per million. Output tokens cost $0.50 per million. Errors do not consume credit. This protects your budget. Prepaid credit never expires. Use the trial credit to test first.