Hermes API: A Developer's Guide to Uncensored Generation

What is the Hermes API?

The hermes api refers to an uncensored large language model endpoint designed for developers who require raw text generation without the content filters typical of major commercial providers. This service operates as a specialized alternative to general-purpose LLM APIs, focusing on a single model ID labeled uncensored. Unlike multi-model gateways that route requests to various vendors, this endpoint serves one open-weight model hosted on dedicated servers, tuned to answer questions on adult, political, or controversial topics without refusal.

The primary use case is integration into applications where content moderation is handled by the client or where the model itself must not block lawful adult content. The API is strictly text-in, text-out. It does not offer embeddings, image generation, or audio processing. Developers seeking a pure text generation engine for adult or unrestricted creative writing will find this endpoint suitable for direct integration into existing codebases.

It is important to note that this is an independent service. It does not serve GPT, Claude, or other vendor models. The model runs on its own infrastructure and is accessed via a standard REST interface. The hermes api name is often used colloquially in the developer community to refer to this specific uncensored generation capability, distinct from the base open-source variants.

Why Choose an Uncensored Model?

Standard LLMs often employ refusal mechanisms that trigger on keywords or context related to adult themes, political dissent, or niche hobbies. For developers building content platforms, roleplay engines, or creative writing tools, these refusals can break the user experience. An uncensored model like the one provided here prioritizes answering the prompt over enforcing a specific moral or safety guideline, provided the content is not illegal (such as involving minors).

Choosing an uncensored endpoint allows for greater control over the final output. If you need the model to describe violence, sexual themes, or controversial historical events without a 403 or a filtered response, this API is designed for that purpose. It is particularly useful for uncensored llama and uncensored mistral enthusiasts who want the behavior of those base models without the additional safety layers added by commercial providers.

• Consistency: The model does not randomly refuse based on vague context.
• Creative Freedom: Ideal for fiction, erotica, or edgy humor generation.
• Simplicity: One model, one behavior, no complex routing logic.

Compatibility with OpenAI SDKs

The most significant advantage of this endpoint is its strict adherence to the OpenAI API specification. You can use the official openai Python SDK, the Node.js client, or any other OpenAI-compatible library by simply changing the base URL and API key. The endpoint supports POST /v1/chat/completions and GET /v1/models, ensuring that standard request bodies and response structures work out of the box.

To integrate, you replace the default base URL with https://api.openrouternsfw.com/v1 and provide your API key. The model ID you send in the request body is uncensored. This means your existing code for handling chat histories, system prompts, and user messages requires no modification. This compatibility extends to uncensored grok and deepseek api users who are already familiar with the OpenAI JSON structure.

The endpoint supports streaming responses via Server-Sent Events (SSE), allowing you to process tokens as they are generated. It also supports function calling (tools), JSON mode for structured output, and standard parameters like temperature and top_p. This makes it a drop-in replacement for many standard LLM integrations.

Configuration: Temperature and Top P

Controlling the randomness and creativity of the output is achieved through standard parameters. The temperature value adjusts the probability distribution of the next token. A lower temperature (e.g., 0.2) makes the output more deterministic and focused, while a higher temperature (e.g., 0.8) increases creativity and variability. For adult content generation, a moderate temperature often yields the best balance between coherence and variety.

The top_p parameter controls the nucleus sampling. It limits the model to consider only the tokens whose cumulative probability exceeds p. This is another way to control randomness, often used in conjunction with temperature. For example, a top_p of 0.95 means the model considers only the most likely 95% of tokens.

Other supported parameters include stop sequences, seed for reproducibility, and presence_penalty and frequency_penalty to discourage repetition. These configurations are passed in the request body just as you would with any OpenAI-compatible model. Adjusting these settings allows you to fine-tune the hermes api output for specific styles or levels of detail.

Handling Streaming Responses

Streaming is essential for real-time user experiences. The API supports Server-Sent Events (SSE), allowing you to receive tokens as they are generated rather than waiting for the full response. This reduces perceived latency and improves the user experience for chat interfaces.

When using the official SDKs, streaming is enabled by setting stream=True in the request. The SDK will yield chunks of data as they arrive. The final chunk in the stream typically contains the usage statistics, including the number of input and output tokens. This allows you to track costs accurately in real-time.

For non-SDK implementations, you can parse the SSE stream directly. Each chunk starts with data: followed by a JSON object. The last chunk will have data: [DONE]. Ensure your client handles potential network interruptions gracefully, as streaming connections can drop. The hermes api ensures that usage data is reliably reported in the final chunk for billing purposes.

Token Efficiency and Limits

The model supports a context window of 100,000 tokens, which includes both the prompt and the completion. This is sufficient for most long-form content generation and complex reasoning tasks. There is no separate output cap per request, and if you do not specify max_tokens, the response can run to the end of the window. For very long responses, you may need to implement logic to chunk the prompt or request multiple completions.

Pricing is transparent and based on token usage. Input tokens cost $0.15 per 1 million tokens, and output tokens cost $0.50 per 1 million tokens. Errors and refusals (for the minor content filter) are free, so you only pay for successful generations. This model is efficient for high-volume text generation.

• Context Window: 100,000 tokens total.
• Max Output: up to the end of the 100,000-token window.
• Rate Limit: 300 requests per minute per key.
• Concurrency: 8 simultaneous requests per key.

Comparison with Other Models

When evaluating the hermes api, it is helpful to compare it with other uncensored llama or uncensored mistral options. Unlike self-hosted solutions like Ollama, this service requires no infrastructure management. You get a reliable endpoint without configuring GPUs or managing model weights. Unlike multi-model gateways, it offers a single, consistent behavior without routing overhead.

Compared to commercial models like GPT-4o or Claude, this endpoint is significantly cheaper for high-volume text generation and does not apply content filters. However, it may not match the reasoning capabilities of the largest proprietary models. It is best suited for tasks where content flexibility is more important than state-of-the-art logic.

For deepseek api users, the pricing structure is competitive, but the model architecture is different. The hermes api is optimized for uncensored text generation, making it a specialized tool rather than a general-purpose AI. If you need embeddings or image generation, you will need to use a different service, as this endpoint is text-only.

Getting Started with Code Examples

Integrating the API is straightforward. You need an API key, which you can generate by signing up with Google or email. The key is provided immediately. Then, configure your SDK with the base URL https://api.openrouternsfw.com/v1 and the model ID uncensored.

Here is a basic Python example using the official SDK:

Copyfrom openai import OpenAI

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

And a Node.js example:

Copyimport OpenAI from "openai";

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

For streaming responses, the SDK handles the SSE parsing automatically. You can iterate over the chunks as they arrive. This allows for real-time text display in your application. The hermes api ensures that the response format matches the OpenAI standard, so no custom parsing logic is required for standard use cases.

More guides

• Free Alternative to OpenRouter? What You Actually Get
• How to Use OpenRouter on Janitor AI: Proxy Setup
• Open Source Discord Bot With an Uncensored LLM