[Dagon Inference](https://inference.dagon.so/) / OpenRouter-style router for abliterated models: cheapest provider, fallback and signed receipts

# Is there an OpenRouter-style router for abliterated models?

Published 2026-11-19 · Last updated 2026-11-20

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

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?

| Model | Model id | Providers, cheapest first (input / output per 1M tokens) |
| --- | --- | --- |
| [GLM-5.3 Abliterated API](https://inference.dagon.so/models/glm-5.3-abliterated) | `glm-5.3-abliterated` | Refuseless (`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 API](https://inference.dagon.so/models/glm-5.3-flash-abliterated) | `glm-5.3-flash-abliterated` | AbliteratedLLM (`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 API](https://inference.dagon.so/models/deepseek-v4.1-flash-abliterated) | `deepseek-v4.1-flash-abliterated` | Lutheos (`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](https://inference.dagon.so/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](https://inference.dagon.so/models/abliterated-model-large-flash), abliteration.ai), `abliterated-model` ([Abliterated Model API](https://inference.dagon.so/models/abliterated-model), abliteration.ai), `abliterated-model-large-v2` ([Abliterated Large v2 API](https://inference.dagon.so/models/abliterated-model-large-v2), abliteration.ai) and `kimi-k3.1-pro-abliterated` ([Kimi K3.1 Pro Abliterated API](https://inference.dagon.so/models/kimi-k3.1-pro-abliterated), Silk Compute) have one provider, which serves every request for them.

Every model and price, abliterated or not, is on [the pricing page](https://inference.dagon.so/abliterated-llm-pricing); [the providers guide](https://inference.dagon.so/abliterated-model-api-providers) 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](https://inference.dagon.so/docs/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](https://inference.dagon.so/run-abliterated-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](https://inference.dagon.so/app/), fund it with USDC from $5, or pay per request with [x402](https://inference.dagon.so/x402-llm-api), and point an OpenAI SDK at `https://inference.dagon.so/v1` or an Anthropic SDK at `https://inference.dagon.so`. The [USDC comparison](https://inference.dagon.so/best-uncensored-llm-api-usdc) 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](https://inference.dagon.so/app/)

## Related guides

- [Uncensored OpenAI-compatible API for security research without refusals](https://inference.dagon.so/cybersecurity-llm-api)
- [Audit smart contracts with an uncensored LLM](https://inference.dagon.so/smart-contract-audit-llm)
- [No-KYC LLM API: use it without KYC and pay with crypto (any coin or USDC)](https://inference.dagon.so/pay-for-llm-api-with-usdc)
- [Best uncensored LLM API you can pay for with USDC: options compared](https://inference.dagon.so/best-uncensored-llm-api-usdc)
- [Use an uncensored LLM with the OpenAI or Anthropic SDK](https://inference.dagon.so/uncensored-llm-openai-sdk)
- [Anthropic Messages API compatible endpoint for uncensored models](https://inference.dagon.so/anthropic-messages-api-uncensored-models)
- [Use Dagon from your boat box: coding agents in a boat sandbox on an uncensored LLM API](https://inference.dagon.so/use-dagon-from-boat)
- [Abliterated LLM API pricing: what each model costs, by provider](https://inference.dagon.so/abliterated-llm-pricing)
- [Providers that host abliterated (refusal-removed) open-weight models through an API](https://inference.dagon.so/abliterated-model-api-providers)
- [How to run abliterated or unverified open-weight models safely in an AI agent](https://inference.dagon.so/run-abliterated-models-safely)
- [Prepaid LLM API key an AI agent buys with stablecoins (USDC) instead of a credit card](https://inference.dagon.so/buy-llm-credits-from-an-agent-wallet)
- [x402 LLM API: an AI agent pays per request for LLM inference in USDC on Solana](https://inference.dagon.so/x402-llm-api)
