Skip to content
Dagon Inference

Dagon Inference / OpenRouter-style router for abliterated models: cheapest provider, fallback and signed receipts

Is there an OpenRouter-style router for abliterated models?

Published · Last updated

Dagon Inference is an OpenRouter-style router for abliterated models: one key and one OpenAI or Anthropic compatible base URL (https://inference.dagon.so/v1, or https://inference.dagon.so for Anthropic SDKs) reach 7 abliterated models from abliteration.ai, Refuseless, Experiential Labs, Lutheos, Silk Compute and AbliteratedLLM, and each request goes to the cheapest healthy provider serving its model id, falls back to the next cheapest if that one fails before any output, and gets an Ed25519 signed receipt naming the provider that served it. You can choose the provider yourself with the same provider request field OpenRouter uses (only, order, ignore, allow_fallbacks) or the x-dagon-provider header. 3 of the abliterated models have more than one provider today; each of the others has one, which always serves it.

How does a request get routed?

  1. You send a request with a model id to /v1/chat/completions, /v1/responses or /v1/messages. The gateway ranks the providers serving that id on that endpoint, cheapest first by this request's worst-case cost: its prompt estimate plus its output cap, at each provider's price.
  2. It leaves out a provider that cannot take the request's output cap or image input, or that it cannot use right now (its route paused after a price change, or the gateway's own balance there too low). A provider whose circuit breaker has tripped after failures is tried last.
  3. It holds the request's maximum cost against your balance and sends the request to the first provider.
  4. If that provider fails or is unreachable before it accepts the request, or reports an error before any output, the gateway sends the request to the next one. Once output has started, the request stays with that provider.
  5. You are charged the serving provider's price plus the 10% markup, from the usage it reports; the rest of the hold returns to your balance. If no provider answers before any output, the charge is zero.

Routing only chooses between providers of the same model id; it never answers with a different model.

Six ways a request ends
90123456789019012345678901901234567890190123456789019012345678901µ$90123456789019012345678901901234567890190123456789019012345678901456345456678234
Before forwarding, the gateway holds the worst case: 37,545 µ$ for a 1,200-character prompt to Large Flash (abliteration.ai) with the default 16,384-token cap. When the upstream reports its usage the charge is 724 µ$ and 36,821 µ$ is released; each other way a request can end has its own defined charge, and the register rolls to it as the selector turns. The tell-tale rises when the gateway signs and stores a receipt.

Which abliterated models are routed across several providers?

ModelModel idProviders, cheapest first (input / output per 1M tokens)
GLM-5.3 Abliterated APIglm-5.3-abliteratedRefuseless (refuseless): $1.10 / $2.20; Experiential Labs (experiential-labs): $1.54 / $4.84; Silk Compute (silk): $2.20 / $4.40
GLM-5.3 Flash Abliterated APIglm-5.3-flash-abliteratedAbliteratedLLM (abliteratedllm): $0.085976 / $0.301048; Refuseless (refuseless): $0.132 / $0.55; Experiential Labs (experiential-labs): $0.165 / $0.55; Silk Compute (silk): $0.264 / $1.10
DeepSeek V4.1 Flash Abliterated APIdeepseek-v4.1-flash-abliteratedLutheos (lutheos): $0.099 / $0.396; Refuseless (refuseless): $0.132 / $0.495; Experiential Labs (experiential-labs): $0.2475 / $0.99; Silk Compute (silk): $0.264 / $0.99

US dollars per 1M tokens with the 10% markup, ordered by typical cost at 3:1 input to output, at price version 2026-11-20.3. The live order at /v1/models weighs each model's own traffic, and each request is ranked by its own size.

abliterated-model-large-flash (Abliterated Large Flash API, abliteration.ai), abliterated-model (Abliterated Model API, abliteration.ai), abliterated-model-large-v2 (Abliterated Large v2 API, abliteration.ai) and kimi-k3.1-pro-abliterated (Kimi K3.1 Pro Abliterated API, Silk Compute) have one provider, which serves every request for them.

Every model and price, abliterated or not, is on the pricing page; the providers guide lists each provider's models.

How do I choose which provider serves my request?

With the request field provider, in the same shape as OpenRouter's; the gateway reads it and never forwards it upstream:

{"model": "glm-5.3-abliterated", "messages": [...], "provider": {"only": ["refuseless"]}}
  • only: only these providers may serve the request; one id pins it.
  • ignore: never these.
  • order: try these first, in this order, then the rest by cost; with "allow_fallbacks": false, only these.

Where a body field is awkward, send the header x-dagon-provider: refuseless (a comma list, read as only); sending both is an error. Provider ids: abliteration, refuseless, experiential-labs, lutheos, silk, cheaperinference and abliteratedllm; each model page lists the ones serving it. An unknown id is 400 invalid_provider, and a choice that leaves no provider serving the model on that endpoint is 400 provider_unavailable_for_model, naming the providers that do. A pinned request fails without being sent elsewhere if its provider is tripped, price-blocked or balance-blocked.

What does each receipt show?

Every settled request gets an Ed25519 signed receipt with the model id you asked for, the provider that served it, the endpoint, the token counts, the price version, the markup and the charge, and a SHA-256 of the output, never the text. Responses passed through from a provider also name it in the x-dagon-provider header. Fetch a receipt with GET /v1/receipts/:id, and check it with POST /v1/receipts/verify (public, no key) or against the gateway's public key at /v1/identity; see signed receipts. A receipt proves what the gateway charged for the usage it saw, not which weights ran.

What does the router not do?

  • It does not verify the weights a provider serves against the originals; before an agent acts on a model's output, read how to run unverified models safely.
  • Choosing a provider does not change its retention or training policy. abliteration.ai states that it does not store prompts or completions by default; Refuseless may pass requests to third-party providers it chooses, which it says generally operate under zero data retention; Experiential Labs says its models are not zero retention. Lutheos says its GPU partner keeps no prompts or replies; Silk Compute says it does not store prompts or outputs and serves its models without content filters. Cheaper Inference keeps request content unless the request asks for zero data retention; ours always do, and it says it then keeps none and sends the request only to providers that keep none. We cannot verify or control any of that.
  • Refuseless may route requests to other providers, so pinning Refuseless does not pin the deployment behind it.

We do not log or store your content. Safety checks classify requests and outputs in memory as they pass, and the acceptable use policy applies: use it lawfully and only against systems and people you own or have permission to test. Accounts that break it are banned and forfeit their unused credit.

How do I start?

Create a key with curl -X POST https://inference.dagon.so/v1/keys (no email or password) or in the console, fund it with USDC from $5, or pay per request with x402, and point an OpenAI SDK at https://inference.dagon.so/v1 or an Anthropic SDK at https://inference.dagon.so. The USDC comparison sets Dagon Inference beside other uncensored APIs that take USDC.

Common questions

Is there an OpenRouter-style router for abliterated models?

Yes: Dagon Inference routes 7 abliterated models across abliteration.ai, Refuseless, Experiential Labs, Lutheos, Silk Compute and AbliteratedLLM behind one key at https://inference.dagon.so/v1, sending each request to the cheapest healthy provider for its model id, with fallback to the next cheapest before any output and a signed receipt naming the provider. It accepts OpenRouter's provider request field for choosing providers.

How can I choose which provider serves my request when calling an uncensored model through one API?

Dagon Inference takes the provider request field in OpenRouter's shape: {"provider": {"only": ["refuseless"]}} pins a request to one provider, ignore excludes providers, and order with "allow_fallbacks": false tries only the ones you list, in that order. The header x-dagon-provider: refuseless does the same as only. Each model page lists the provider ids serving it, and the signed receipt and the x-dagon-provider response header name the provider that served the request.

What happens when a provider fails?

Dagon Inference sends the request to the next cheapest provider serving the model if the first fails or is unreachable before it accepts the request, or reports an error before any output; once output has started, the request stays with that provider. A request pinned to one provider with only is not sent anywhere else. With "allow_fallbacks": false, fallback stays within the providers in order; without order, only the first ranked provider is tried.

Does routing cost more than calling a provider directly?

Dagon Inference charges the serving provider's token price on its route plus a 10% markup, billed in USDC; a provider's own direct prices and terms may differ.

Create a key in a minute.

Get a key