Cursor Integration Guide: OpenAI Compatible API

Base URL and Authentication

Cursor uses your API key to route requests to our hosted endpoint. Replace the standard OpenAI base URL with our specific domain to enable uncensored generation without modifying your client code. You receive one active key per account, which you can generate instantly via Google or email login.

Configure your environment variable or IDE settings to point to HTTPS://api.cursoropenaiapikey.com/v1. The model identifier is simply "uncensored". This setup ensures every request bypasses default content filters while maintaining full compatibility with existing integrations.

The base URL is HTTPS://api.cursoropenaiapikey.com/v1. Pass your key in the Authorization header as a Bearer token. This method works with any OpenAI SDK compatible client.

• Base URL: HTTPS://api.cursoropenaiapikey.com/v1
• Model ID: uncensored
• Auth: Bearer token in header

Making Your First Request

Send a standard chat completion request to verify connectivity and billing. Our endpoint accepts the same JSON structure as OpenAI, ensuring immediate compatibility with your existing scripts. The response returns generated text along with token usage metrics.

Use the following cURL command to test the endpoint. Replace YOUR_API_KEY with the key generated from your dashboard. The request includes a simple system prompt to demonstrate the uncensored capability.

Copycurl https://api.cursoropenaiapikey.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Show me the current weather in Berlin"}]
  }'

Successful responses include token counts for input and output. Errors like 401 indicate an invalid key, while 402 signals insufficient credit. Check your account balance if the request fails.

Python SDK Integration

Use the official OpenAI Python library with a custom base URL to interact with our API. This approach allows you to leverage existing codebases without rewriting client logic. Set the base URL and API key before initializing the client.

Initialize the client with your credentials and the correct base URL. Then call chat.completions.create with the model ID "uncensored". The response object provides access to the generated content and usage statistics.

Copyfrom openai import OpenAI

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

This method ensures compatibility with standard Python workflows. You can pass additional parameters like temperature or stop sequences to control generation. The SDK handles serialization and response parsing automatically.

Node.js SDK Integration

Integrate the Node.js OpenAI package to send requests from your JavaScript or TypeScript applications. Configure the client with our base URL to enable uncensored generation. This setup works seamlessly with existing Node projects.

Create a new OpenAI client instance with your API key and the correct base URL. Then invoke the chat.completions.create method. The response provides the generated text and token usage data.

Copyimport OpenAI from "openai";

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

This integration supports all standard parameters. You can adjust temperature, top_p, and other settings to fine-tune the output. The SDK handles network requests and response parsing efficiently.

Streaming Responses

Enable streaming to receive tokens as they are generated. This reduces perceived latency for coding workflows and interactive applications. The API sends Server-Sent Events (SSE) with each token.

Set the stream parameter to true in your request. The response will include multiple chunks. Token usage metrics are included in the final chunk to avoid billing discrepancies. This method is ideal for real-time user interfaces.

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 the stream events in your client code. Aggregate the token content as it arrives. The final chunk contains the total token usage for accurate billing. This approach ensures low-latency delivery without sacrificing accuracy.

Rate Limits and Context Window

Our API enforces strict rate limits to ensure consistent performance. Each key supports 300 requests per minute and 8 concurrent requests. The maximum request body size is 8 MB. Exceeding these limits returns a 429 error.

The context window is 100,000 tokens for the combined prompt and completion. The maximum output per request is 16,000 tokens. If max_tokens is unset, the default is 2,048 tokens. Plan your prompts accordingly to avoid truncation.

• Rate Limit: 300 requests/minute
• Concurrent Requests: 8
• Context Window: 100,000 tokens
• Max Output: 16,000 tokens