What is XAI API?
The XAI API is the programmatic interface for xAI’s large language models, primarily known as Grok. It allows developers to integrate xAI’s reasoning capabilities into applications using standard HTTP requests. The API typically follows conventions established by other major providers, making it accessible to developers already familiar with modern LLM ecosystems.
When interacting with the XAI API, you send prompts and receive text responses. The service is designed for tasks ranging from creative writing to complex reasoning. However, it operates under xAI’s specific terms, pricing structures, and model versions, which can change without notice.
Developers using the XAI API must adhere to rate limits and content policies defined by xAI. The API does not expose the underlying model weights, meaning you are reliant on xAI’s infrastructure for availability and performance. For the most accurate details on current model versions, token limits, and pricing tiers, you should consult xAI’s official documentation directly.
Why Consider an Alternative?
While the XAI API is robust, some developers find it lacks flexibility in billing or content generation. Many vendors lock features behind expensive monthly subscriptions or tiered plans that restrict usage. If you need uncensored generation for lawful adult content, security research, or controversial topics, standard APIs often apply strict refusals.
Billing complexity is another common pain point. Traditional providers often require credit cards, handle currency conversions, or charge for idle time. Apertus simplifies this with a prepaid crypto model. You pay only for the tokens you use, with no monthly fees and no expiration on your credit.
Additionally, if you require a single, dedicated model rather than a routing service, a focused API like Apertus reduces latency and predictability. By avoiding multi-model routing, you ensure consistent behavior for your application. This is particularly useful for developers who need deterministic outputs for specific tasks without the variability of switching between different model versions.
Apertus: The Uncensored Option
Apertus is an independent API that serves a single, open-weight uncensored large language model. It is designed to answer questions without content refusals for lawful adult use, making it ideal for creative writing, roleplay, or research where standard filters might interfere. The model is hosted on Apertus’s own servers and is not affiliated with xAI, OpenAI, or any other major vendor.
The API is OpenAI-compatible, meaning you can use the same SDKs and client code you already know. You simply change the base URL to https://api.apertus.top/v1 and provide your API key. The model ID to use is uncensored.
Key features include streaming via Server-Sent Events (SSE), function calling with tools, and strict JSON mode output. You can control generation parameters like temperature, top_p, stop sequences, and seeds. The context window supports up to 64,000 tokens total, with a maximum output of 16,000 tokens per request.
Billing Comparison
Apertus offers a transparent, pay-per-token billing model. The rates are $0.25 per 1 million input tokens and $1.00 per 1 million output tokens. Unlike many competitors, there are no monthly subscriptions, no tier locks, and no hidden fees. Your prepaid credit never expires, and you only pay for actual token usage. Errors and refusals are free, so you don’t pay for failed requests.
Top-ups are handled exclusively via cryptocurrency. You can top up using USDT (TRC20) or USDC (Base) in whole amounts from $10 to $500. Bonuses are applied automatically: +5% bonus credit for top-ups of $50 or more, and +10% for top-ups of $100 or more. There are no credit cards, PayPal, or bank transfers.
| Feature | Apertus | Typical XAI/Other APIs |
|---|---|---|
| Billing Model | Prepaid Crypto, Pay per Token | Subscription or Pay-as-you-go (Card) |
| Expiration | Never | Varies (often 30-90 days) |
| Refund Policy | Credit not refunded; errors free | Varies by provider |
| Trial | $0.50 for 7 days | Varies |
Technical Compatibility
Apertus is fully compatible with the OpenAI SDKs and any client that supports the OpenAI API specification. This means you can use the same Python, Node.js, or cURL scripts you use for other providers. The only changes required are updating the base_url and the api_key.
The API supports streaming responses via Server-Sent Events (SSE). Token usage is reported in the final chunk of the stream. You can also use function calling with tools and tool_choice, and enforce JSON mode using the response_format parameter. Supported parameters include temperature, top_p, stop, seed, presence_penalty, and frequency_penalty.
Unlike comprehensive APIs, Apertus does not offer embeddings, image generation, audio, video, or fine-tuning. It is a dedicated text API. This focus ensures lower latency and more predictable performance. If you need embeddings, you can use a separate service and combine the results with Apertus’s text generation.
Setup & Integration
Getting started with Apertus is straightforward. Visit the Get API key page to sign up. You can use Continue with Google or create an account with an email and password. No phone number is required. Once registered, your API key is displayed immediately.
You can generate a new key at any time, which will replace the previous one. Each account is limited to one active key at a time. This simplifies key management and security. You can start using the API immediately with your trial credit or after topping up via crypto.
Here is an example of how to make a request using cURL:
curl https://api.apertus.top/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [{"role": "user", "content": "Write a blunt product review of a cheap VPN."}]
}'And here is how you might initialize the client in Python:
from openai import OpenAI
client = OpenAI(base_url="https://api.apertus.top/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)Limits & Performance
Apertus enforces clear rate limits to ensure stability. You are limited to 300 requests per minute per API key and can have up to 8 concurrent requests at the same time. The maximum request body size is 8 MB. These limits are designed to handle high-volume usage without degradation.
The context window is 64,000 tokens, combining both the prompt and the completion. The maximum output per request is 16,000 tokens. If you do not specify the max_tokens parameter, the default output limit is 2,048 tokens. This is sufficient for most short-to-medium length responses.
Content moderation is minimal but specific. The only hard content limit is the refusal of sexual content involving minors. All other lawful adult, fictional, or controversial topics are allowed. This makes Apertus a reliable choice for uncensored applications.
Getting Started with Apertus
To begin using Apertus, sign up for an account. You will receive $0.50 in trial credit, valid for 7 days. No credit card is needed. This allows you to test the API’s performance, latency, and response quality before committing to a top-up.
When you are ready to scale, top up your account with USDT (TRC20) or USDC (Base). The minimum top-up is $10, and the maximum is $500. You will receive bonus credit for larger top-ups: +5% for $50+ and +10% for $100+. Your credit never expires, so you can use it whenever you need it.
Integrate the API into your application by updating your client configuration. Use the uncensored model ID and point to https://api.apertus.top/v1. Start making requests and enjoy transparent, uncensored generation.
