Blog · 2026-09-19 · Vynaris Team

How to Use an Uncensored LLM API: A Getting-Started Guide (2026)

A copy-paste getting-started guide for the Vynaris hosted uncensored profiles: the three model IDs, a first request, streaming, and the per-request receipt.

Calling an uncensored LLM API is the same loop as calling any OpenAI-compatible endpoint: get a key, send a chat completion, read the response. The reduced-refusal part changes what the model is willing to engage with, not the wire protocol. What does change is discipline. The work that runs on these models, authorized security testing, research, and hard evaluation of model behavior, deserves clean attribution: which model answered, what the call cost, and what you sent it.

This guide walks the full path for the Vynaris hosted uncensored profiles: creating a key, funding the account, listing the models, sending a first request in curl, repeating it from Python, streaming a long response, and reading the receipt that ships with every call. By the end you should have a working request, a known cost per call, and a habit of pinning model IDs in your records.

All of the uses this guide assumes are lawful and authorized: security testing on systems you own or are explicitly permitted to assess, cyber defense, research, and evaluation. Do not use reduced-refusal models for exploitation of minors, non-consensual sexual content, unauthorized access, malware deployment against systems you do not own or control, or other prohibited activity. Scope your prompts to work you are allowed to do before you send them.

What you need before you start

A key. Create an account and generate an API key, then save it immediately. Keys look like vyn_sk_live_ followed by a random suffix, 55 characters in total, and the full value is shown exactly once at creation. Keys are hashed server-side and cannot be read back later, only replaced. They are revocable individually and support optional per-key spend caps, so the safe pattern is one key per script or per machine. Keep it in an environment variable, never in committed code.

Prepaid credit. The API runs on prepaid top-ups of $20, $50, $100, $250, or $500 that never expire, with no monthly plan required. Credit stays in your wallet until you spend it. Standing rates are on the Vynaris pricing page.

Any OpenAI-compatible client. The endpoint speaks the OpenAI Chat Completions wire format, so curl, the OpenAI SDKs, and most agent frameworks work once you point them at the API. The Anthropic Python SDK also works through its base_url override. If your tool can call OpenAI, it can call this.

The three hosted profiles

Model ID                              | Input  | Output | Context
vynaris/qwen3.6-35b-a3b-uncensored    | $1.00  | $5.00  | 128K
vynaris/qwen3.8-27b-uncensored        | $1.00  | $7.00  | 128K
vynaris/deepseek-v4-flash-uncensored  | $2.00  | $11.00 | 128K

Rates are per million tokens. Each profile has a live model card, Qwen3.6 35B-A3B uncensored, Qwen3.8 27B uncensored, and DeepSeek V4 Flash uncensored, and each card names the community source build behind the profile, so your attribution starts at the repository. The full directory is at uncensored models.

One property matters more than the rates: a hosted profile is never substituted. When you send one of these three model IDs, that exact model serves the request, and requested_model equals served_model in the response. For evaluation work, that is the difference between a measurement and an anecdote.

Step 1: confirm the key works

Before any model call, check the key and connectivity in one shot:

curl -s https://api.vynaris.com/v1/ping -H "Authorization: Bearer $VYNARIS_API_KEY"

A healthy key returns {"ok": true, "key": "valid"}. This single call bisects most setup problems: if ping succeeds but a completion fails, the fault is in your request, not the network or the key.

Step 2: list the models

Ask the API what your key can call:

curl -s https://api.vynaris.com/v1/models -H "Authorization: Bearer $VYNARIS_API_KEY"

The response lists every model ID available to your account. Copy the three hosted profile IDs from the response rather than from memory, notes, or any blog post including this one: the endpoint is the source of truth for what is callable today.

Step 3: send your first chat completion

curl -s https://api.vynaris.com/v1/chat/completions \
  -H "Authorization: Bearer $VYNARIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "vynaris/deepseek-v4-flash-uncensored",
    "messages": [
      {"role": "user", "content": "Explain how a stack canary detects a buffer overflow attempt, so I can verify my mitigation actually triggers in tests."}
    ]
  }'

The response is a standard Chat Completions body with a Vynaris receipt attached, trimmed here to the fields you read first:

{
  "model": "vynaris/deepseek-v4-flash-uncensored",
  "choices": [
    {
      "index": 0,
      "message": {"role": "assistant", "content": "A stack canary is placed between local buffers and the saved return address, and the runtime checks it before the function returns."},
      "finish_reason": "stop"
    }
  ],
  "usage": {"prompt_tokens": 1180, "completion_tokens": 342, "total_tokens": 1522},
  "vynaris": {
    "request_id": "req_9f2c7d14e6a8",
    "requested_model": "vynaris/deepseek-v4-flash-uncensored",
    "served_model": "vynaris/deepseek-v4-flash-uncensored",
    "cost_usd": 0.006122,
    "baseline": "provider list price, uncached"
  }
}

The vynaris block also carries upstream_model, provider, deployment, routing_reason, attempts, and the direct_equivalent_usd comparison, so every billable fact about the request travels with the response. The same facts ride the response headers: x-vynaris-request-id, x-vynaris-served-model, x-vynaris-cost, and x-vynaris-balance, which reports your remaining balance after the call.

Check the math once so you trust the receipt from then on. This request used 1,180 input and 342 output tokens. At $2.00 per million input and $11.00 per million output, that is 1180 x $2.00 / 1,000,000 = $0.00236 plus 342 x $11.00 / 1,000,000 = $0.003762, a total of $0.006122, which is exactly what cost_usd reports. Nothing is estimated after the fact; the number is measured from the token counts of the request that actually ran. Failed requests are covered by reliability refunds rather than billed.

One behavior to expect on first use: the first request after an idle period can be slower while capacity starts; later requests run at normal latency.

Step 4: move to a real client

The same call from Python, using the OpenAI SDK pointed at the Vynaris base URL:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["VYNARIS_API_KEY"],
    base_url="https://api.vynaris.com/v1",
)

response = client.chat.completions.create(
    model="vynaris/deepseek-v4-flash-uncensored",
    messages=[
        {"role": "user", "content": "Draft a test plan for the auth bypass I described, scoped to my staging environment."}
    ],
)

print(response.choices[0].message.content)

# The vynaris receipt rides in the raw body; the OpenAI SDK
# preserves fields it does not model:
receipt = response.model_extra["vynaris"]
print(receipt["served_model"], receipt["cost_usd"])

Any OpenAI-compatible client in any language works the same way: set the base URL to https://api.vynaris.com/v1, set the key, use the exact model ID. The Anthropic Python SDK works through its base_url override. Nothing about your existing harness has to change.

Step 5: stream long responses

Add "stream": true for anything longer than a paragraph:

curl -N https://api.vynaris.com/v1/chat/completions \
  -H "Authorization: Bearer $VYNARIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "vynaris/qwen3.6-35b-a3b-uncensored",
    "stream": true,
    "messages": [
      {"role": "user", "content": "Write the incident-response playbook section for credential stuffing alerts."}
    ]
  }'

Output arrives as server-sent events, one JSON chunk per group of tokens, ending with the data: [DONE] sentinel. The -N flag disables curl buffering so you see chunks as they arrive. Streaming responses carry the x-vynaris-request-id and x-vynaris-served-model headers, so attribution survives even when the body arrives in pieces. Tool and function-calling requests pass through unchanged: if your agent loop sends tools, the streamed deltas include the same tool-call fragments any OpenAI-compatible client already knows how to assemble.

Pin the model you are testing

Evaluation hygiene is what makes the results defensible later. Three habits carry most of the weight:

Record the exact model ID with every result. Not "DeepSeek", the full vynaris/deepseek-v4-flash-uncensored string, plus the request_id from the receipt. A refusal-rate number without a model ID and a date is marketing, not a measurement.
Rerun your own probe set instead of trusting published scores. Fix temperature and max tokens, keep the prompt file, and rerun when anything changes. The uncensored LLM leaderboard publishes the suite notes and a reproduction script you can point at any endpoint.
Cost per finished task, not cost per token. A model that refuses a third of your hard prompts is expensive at any token price once retries and rewrites enter. The receipt makes this measurable: sum cost_usd over a run and divide by tasks that finished.

Five mistakes to avoid

Pasting the key into client-side code. The key is a bearer credential: anyone holding it spends your credit. Use environment variables, create one key per harness so each can be revoked independently, and set a per-key spend cap on anything that runs unattended.
Not saving the key at creation. The full value is shown once and hashed server-side. If the terminal scrollback is gone, the recovery path is revoking and generating a new key, not retrieving the old one.
Retrying a 402. A 402 means the balance is zero, and it is terminal, not transient. The request was never sent upstream and nothing was charged, so retries accomplish nothing. Top up, then resend. A 502, by contrast, is an upstream failure where retrying is reasonable.
Calling a model ID you did not verify. Copy IDs from /v1/models, not from memory, older notes, or a landing page. An evaluation run against the wrong model is a rerun you pay for twice.
Recording results without the receipt. Log request_id, served_model, and cost_usd for every run. When a number in a report is questioned later, the receipts reconstruct exactly which model produced it and what it cost.

Where to go next

Browse the uncensored model directory and read the model card for each profile you plan to test.
Check Vynaris pricing for standing rates, top-up options, and current terms before you commit budget.
Run the leaderboard reproduction script against the profiles to measure refusal behavior on your own prompts.
If you are weighing this against running your own GPUs, the local versus hosted cost comparison works that math end to end.
If you would rather run the whole stack yourself, how to host an uncensored LLM yourself covers the hardware, the setup, and the running cost.

Frequently asked questions

Do I need a monthly plan to use the hosted profiles?

No. The API runs on prepaid top-ups from $20 that never expire, with no monthly plan and no interactive-use clause, so agents, automation, and production traffic are permitted workloads. Confirm current terms on the pricing page before committing budget.

Which profile should I start with?

Start from rates and your own probe set, not from a benchmark claim. Qwen3.6 lists the lowest output rate at $5.00 per million tokens, Qwen3.8 sits at $7.00, and DeepSeek V4 Flash costs more per output token at $11.00 but carries a different model behind it. Run the same 20 to 30 prompts across all three, record compliance rate, time to first token, and cost_usd per finished task, and let your own workload pick.

Can I keep using my existing OpenAI or Anthropic client?

Yes. The wire format is OpenAI Chat Completions, so any OpenAI-compatible client works after a base URL change to https://api.vynaris.com/v1 and an API key swap. The Anthropic Python SDK works through its base_url override. Streaming and tool-calling requests pass through unchanged.

What happens to my prompts?

The hosted profiles do not persist prompt or output bodies. Per-request metadata such as model, token counts, cost, and latency is retained for billing, and full transcript storage exists only as an explicit opt-in you enable for dashboard debugging. These are product statements, so verify the current privacy terms against your requirements before sending anything regulated.

What happens when the balance runs out mid-run?

The next request returns 402, the request is not sent upstream, and nothing is charged; the body includes a top-up URL. You can see it coming: every response carries the x-vynaris-balance header, and per-key spend caps bound the worst case on unattended runs. Unused credit never expires, so topping up early costs nothing in option value.