# Dagon Inference > Uncensored LLM API for AI agents and developers: any OpenAI or Anthropic SDK, pay per request in USDC on Solana with x402, no account and no SOL needed. Signed receipts. ## For agents: how to pay An agent can buy its own inference, no browser or email. In order of preference: 1. **x402 pay per request** (no key, no setup; USDC on Solana, network fee paid by us, $0.5 to $1,000 a payment). POST the request with no key, get 402 with `accepts`, retry with the signed payment in `X-PAYMENT` or `PAYMENT-SIGNATURE`; keep the key from `x-dagon-key`. Guide: https://inference.dagon.so/x402-llm-api `const res = await wrapFetchWithPaymentFromConfig(fetch, { schemes: [{ network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", client: new ExactSvmScheme(toClientSvmSigner(signer)) }] })("https://inference.dagon.so/v1/chat/completions", { method: "POST", headers: { "content-type": "application/json" }, body })` (@x402/fetch, @x402/svm) 2. **Wallet top-up in two calls** (needs a gk_ key: `curl -X POST https://inference.dagon.so/v1/keys`). Details below and at https://inference.dagon.so/buy-llm-credits-from-an-agent-wallet `curl https://inference.dagon.so/v1/credits/purchase -H "Authorization: Bearer $DAGON_KEY" -H "Content-Type: application/json" -d '{"amount_usd": 20, "payer_wallet": "", "chain": "solana"}'` then sign and send `unsigned_transaction`, then `POST /v1/credits/purchase/confirm {"purchase_id", "signature"}` 3. **MCP server** (local stdio, in the gateway repository's `mcp/` folder, not on npm): tools for models, balance, keys, wallet purchases and chat. `claude mcp add dagon --env DAGON_API_KEY=gk_... -- node /path/to/dagon-inference/mcp/src/index.ts` All three: Solana mainnet USDC to the treasury `9rMdbu4KdLWH2nPXbzhm9HTKaibGZ2ckakQbW1wPh6KK` (check it at https://inference.dagon.so/official); paying wallets are screened against the OFAC SDN list (403 `payment_refused`) and some locations are blocked (451 `location_blocked`); at most $2,000 of paid credit per key in 24 hours. ## About Dagon Inference is a metered gateway in front of upstream model providers: abliteration.ai, Refuseless and Experiential Labs. Each request goes to the cheapest healthy provider serving its model id, with fallback before any output. It is not affiliated with OpenAI, Anthropic or those providers. It is operated by Inkwell Finance, Inc. d/b/a Dagon. - Base URL for OpenAI SDKs: `https://inference.dagon.so/v1`; for Anthropic SDKs: `https://inference.dagon.so` - Auth: `Authorization: Bearer ` (gk_ prepaid key or lk_ private lease key) - Live models and prices (canonical, no key needed): https://inference.dagon.so/v1/models - Snapshot of this table: https://inference.dagon.so/models.json (JSON, documented schema) and https://inference.dagon.so/models.md - OpenAPI 3.1: https://inference.dagon.so/openapi.json ## Buy credits from an agent (wallet) An agent with a Solana wallet funds its own gk_ key in USDC with no browser and no email (guide with TypeScript and Python scripts: https://inference.dagon.so/buy-llm-credits-from-an-agent-wallet): 1. `POST https://inference.dagon.so/v1/credits/purchase` with `Authorization: Bearer ` and `{"amount_usd": 20, "payer_wallet": "", "chain": "solana"}` ($5 to $1,000, whole cents). Returns `purchase_id`, `amount_total`, `currency` ("usdc"), `unsigned_transaction` (base64), `blockhash`, `last_valid_block_height`, `fee_sponsored`, `expires_at`, `confirm_url`. 2. Deserialize `unsigned_transaction` (@solana/web3.js `VersionedTransaction.deserialize`), sign it with the wallet, send it (`sendRawTransaction`) and confirm it. The blockhash expires about a minute after step 1; if it does, repeat step 1. 3. `POST https://inference.dagon.so/v1/credits/purchase/confirm` with `{"purchase_id", "signature"}`. 200 `{"status": "credited", "credited_usd", "balance"}` once the payment is final (the call can take up to about 45 s); 202 `{"status": "pending"}` means call it again after `retry_after_s`. `GET https://inference.dagon.so/v1/credits/purchase/{purchase_id}` reads the status. When `fee_sponsored` is true the transaction is already signed by the payment service's fee payer, which pays the network fee and any account rent: keep that signature (sign with the wallet only) and the wallet needs no SOL, only the USDC. When false, the wallet pays the network fee in SOL. Errors: 400 `invalid_wallet`, 403 `payment_refused` (sanctioned wallet), 451 `location_blocked`. ## Models and prices USD per 1M tokens, 10% markup included (15% in total on private leases). Build snapshot at price version 2026-11-02.2, as of 2026-11-02. Prices follow the providers and may have changed since; the live prices and current price version are at https://inference.dagon.so/v1/models (no key needed). | Model id | Model | Input | Cached input | Output | Context | Max output | Providers | | --- | --- | --- | --- | --- | --- | --- | --- | | `abliterated-model-large-v2` | [Abliterated Large v2](https://inference.dagon.so/models/abliterated-model-large-v2) | $1.10 | $0.165 | $2.20 | 1,048,576 | 65,536 | abliteration.ai, Refuseless, Experiential Labs | | `deepseek-v4.1-flash-abliterated` | [DeepSeek V4.1 Flash Abliterated](https://inference.dagon.so/models/deepseek-v4.1-flash-abliterated) | $0.132 | $0.0275 | $0.495 | 1,048,576 | 65,536 | Refuseless, Experiential Labs | | `glm-5.3-flash-abliterated` | [GLM-5.3 Flash Abliterated](https://inference.dagon.so/models/glm-5.3-flash-abliterated) | $0.132 | $0.044 | $0.55 | 1,048,576 | 65,536 | Refuseless, Experiential Labs | | `abliterated-model-large-flash` | [Abliterated Large Flash](https://inference.dagon.so/models/abliterated-model-large-flash) | $1.10 | $0.11 | $2.20 | 1,048,576 | 65,536 | abliteration.ai | | `abliterated-model` | [Abliterated Model](https://inference.dagon.so/models/abliterated-model) | $1.10 | $0.11 | $3.30 | 262,144 | 65,536 | abliteration.ai | Each model is priced at the cheapest provider serving it plus the markup. A request that falls back to another provider is billed at that provider's rate plus the markup; its signed receipt names the provider and the price version. Billing is in whole millionths of a dollar, rounded up once per request. ## Quick start ```sh # 1. Create a key (no email, no password); save the "key" field, it is shown once curl -X POST https://inference.dagon.so/v1/keys # 2. Fund it in USDC: returns a hosted checkout link curl https://inference.dagon.so/v1/credits/checkout -H "Authorization: Bearer $DAGON_KEY" -H "Content-Type: application/json" -d '{"amount_usd": 20}' # 3. Call a model curl https://inference.dagon.so/v1/chat/completions \ -H "Authorization: Bearer $DAGON_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "abliterated-model-large-flash", "messages": [{"role": "user", "content": "Hello"}]}' ``` ## Use it - OpenAI SDKs: base URL `https://inference.dagon.so/v1` (Chat Completions at /v1/chat/completions, Responses at /v1/responses) - Anthropic SDKs: base URL `https://inference.dagon.so` (Messages at /v1/messages) - Auth: `Authorization: Bearer ` with a gk_ prepaid key or an lk_ private lease key - Create a key: `curl -X POST https://inference.dagon.so/v1/keys` (no email, no password) - Fund it in USDC: `POST https://inference.dagon.so/v1/credits/checkout {"amount_usd": 20}` returns a hosted checkout link ($5 to $1,000 per top up) - Official domains and payment addresses, to check a checkout before you pay: https://inference.dagon.so/official - No key yet? Pay per request with x402: see "Pay per request (x402)" below - Each model's endpoints are listed in /v1/models; not every provider serves Responses or Messages - Web console: https://inference.dagon.so/app/ - API description: https://inference.dagon.so/openapi.json (also linked from https://inference.dagon.so/.well-known/api-catalog) ## Pay per request (x402) The inference routes (/v1/chat/completions, /v1/responses, /v1/messages) speak [x402](https://x402.org), versions 1 and 2, `exact` scheme, USDC on Solana mainnet. No account, no checkout page: an agent with a Solana wallet holding USDC can pay with the request. 1. Send the request without a key. The answer is HTTP 402. Its JSON body keeps the usual `error` object (code `payment_required`) and adds the x402 v1 `PaymentRequired` fields `x402Version` and `accepts`; the `PAYMENT-REQUIRED` header carries the same requirements as x402 v2 (base64 JSON). `network`: `solana` (v1) / `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` (v2); `asset`: USDC `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`; `payTo`: the treasury `9rMdbu4KdLWH2nPXbzhm9HTKaibGZ2ckakQbW1wPh6KK` (its USDC account `E6dUxbCSJ3ygHSuT5DrjLDJediPzHiKQy2nJHb115nfg`); `maxAmountRequired` / `amount`: this request's maximum cost in USDC base units (micro-USD), at least $0.5; `extra.feePayer`: the gateway's fee payer when it sponsors network fees. 2. Sign a transaction that transfers that amount with SPL Token `TransferChecked` from your own USDC account (your associated token account) to the treasury's, with `extra.feePayer` as fee payer, and do not broadcast it. Compute budget, memo and wallet-injected Lighthouse instructions are allowed; other programs and address lookup tables are not. Without `extra.feePayer`, be your own fee payer and sign fully. 3. Retry the same request with the base64 payment payload in `X-PAYMENT` (v1) or `PAYMENT-SIGNATURE` (v2). The gateway checks the transaction, screens the paying wallet against the OFAC SDN list, refuses blocked locations, co-signs as fee payer, broadcasts and waits for confirmation, then serves the request. 4. The response carries `X-PAYMENT-RESPONSE` / `PAYMENT-RESPONSE` (base64 JSON with the transaction signature) and `x-dagon-key`: a new gk_ prepaid key holding the payment minus this request's cost. Use it as `Authorization: Bearer` for the next requests; pay again when it runs out. With a key whose balance is too low, the 402 (code `insufficient_credits`) asks for a top-up of at least $1 or the shortfall; paying it with the key in `Authorization` credits that key. A transaction is credited once: a replay gets 402 `duplicate_settlement`. If confirmation takes too long the answer is 402 `settlement_pending` with `x-dagon-key`; retry the same request with that key and the same payment header. Clients: `@x402/fetch` or `@x402/axios` with `ExactSvmScheme` from `@x402/svm` and a Solana signer (network `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`), or the v1 packages `x402-fetch` / `x402-axios` with `createSigner("solana", privateKey)` (raise their default maximum payment for large requests). Read `x-dagon-key` from the first paid response and keep it. ## Questions ### What is Dagon Inference? A metered endpoint in front of abliteration.ai, Refuseless and Experiential Labs. You call it with an OpenAI or Anthropic SDK; it forwards each request to the cheapest healthy provider serving that model id, falls back to the next cheapest if that provider fails before any output, meters every token and charges your key the routed provider's price plus the markup, based on the usage the upstream reports. When none is reported, we charge an estimate or the reserved maximum. ### Which uncensored models does Dagon Inference serve? Abliterated Large v2 (abliterated-model-large-v2): $1.10 input, $2.20 output per 1M tokens; DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated): $0.132 input, $0.495 output per 1M tokens; GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated): $0.132 input, $0.55 output per 1M tokens; Abliterated Large Flash (abliterated-model-large-flash): $1.10 input, $2.20 output per 1M tokens; Abliterated Model (abliterated-model): $1.10 input, $3.30 output per 1M tokens. All are abliterated builds with refusal behavior reduced or removed. Prices include the 10% markup; the live list is GET /v1/models. ### What if I lose my API key? We do not recover it, transfer its balance or refund it, because we store only a hash of each key and cannot verify who owns one. Save the key in a password manager when you create it. If you sign in with a passkey instead, a lost key is easy to replace: delete it, the balance returns to your account, and you mint another. Wallet login can keep your keys in an encrypted vault, but a key you never saved there cannot be restored. ### Can I sign in with a passkey and give keys to my agents? Yes. Continue with a passkey in the console: it works with 1Password, Windows Hello, iCloud Keychain and security keys, and we store only its public key, no email and no vault. Your balance sits on your account, and you mint separate keys for each agent or teammate, fund each one with what it needs, take the money back, or delete a key. Keys under one account can be linked to each other. ### Do I need to sign up? No. One request creates a prepaid key, with no email and no password, and you fund it with USDC through hosted checkout, $5 to $1,000 at a time. A private lease from a zkAPI server needs no key creation at all. ### How do I know a checkout page is really yours? Our checkout runs only at https://pay.dagon.so, and you reach it only from a top up you start in the console or with POST /v1/credits/checkout. It asks your wallet for exactly the amount you chose, paid to our treasury on Solana or through Circle's CCTP contract from another chain, and a Solana payment expires about a minute after the checkout prepares it. Our domains and the treasury, relayer and contract addresses are listed at https://inference.dagon.so/official; check them in full before you approve. We never ask you to pay by direct message, ad or a link we did not generate. ### What does one request cost? The model's token rates plus 10% (15% on private leases, which also pay for the SOL to USDC swap), in whole millionths of a dollar, rounded up once per request. The worked example on this page, 1,200 characters to Large Flash with 238 tokens back, costs 724 µ$, about $0.0007. ### Why hold more than a request costs? So two requests can never spend the same balance. The hold covers the prompt estimate plus your output cap (16,384 tokens unless you set one, 65,536 at most), and the unused part returns the moment the upstream reports usage. ### What if my stream drops halfway? You pay for the estimated prompt plus the text that was streamed before you left, at one token per three characters. If the upstream fails or is unreachable before it accepts the request, or reports an error before any output, the charge is zero. If usage is not reported or a request is cut off, you pay an estimate, which can be higher than the real cost. ### Do you store prompts or outputs? The gateway does not store or log them: they pass through memory to the provider that serves the request (abliteration.ai, Refuseless or Experiential Labs). The database keeps keys, holds, credits and receipts (ids, token counts, prices, a hash of the output). The gateway sees content, and your IP address, in transit; that provider sees content and timing. 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. We cannot verify or control any of that. ### How do I check a receipt? Every response carries a receipt id. Fetch the receipt, verify its Ed25519 signature against the key at /v1/identity, and recompute the charge from the published rates. POST /v1/receipts/verify does all three for you. ### Why is web search refused? Upstream providers bill searches separately from tokens, and a token meter cannot see that cost. Rather than guess, the gateway answers 400 web_search_not_supported before anything is held or sent. ### Can an AI agent pay for API calls itself? Yes, three ways, none needing a browser or an email. With x402 the agent sends the request with no key, gets a 402 with the price, and retries with a signed USDC transfer on Solana; the answer comes back with a prepaid key for later requests. With a key, it can top up from its own wallet in two calls: POST /v1/credits/purchase returns a USDC transaction to sign and send, and POST /v1/credits/purchase/confirm credits the key. Or it can use the local MCP server, which wraps keys, purchases and chat as tools. ### What is x402 and do you support it? x402 is an open protocol that uses HTTP status 402 Payment Required to let a client pay for a request inside the request. We support x402 versions 1 and 2, exact scheme, USDC on Solana mainnet, on /v1/chat/completions, /v1/responses and /v1/messages. The 402 body carries the v1 requirements (x402Version, accepts) next to the usual error object, the PAYMENT-REQUIRED header carries v2, and the retry sends the payment in X-PAYMENT or PAYMENT-SIGNATURE. A keyless request pays its maximum cost, at least $0.5; one payment is at most $1,000, and a key receives at most $2,000 of paid credit a day. Guide: https://inference.dagon.so/x402-llm-api ### Does my agent need SOL? No. For x402 the 402 names the gateway's fee payer in extra.feePayer; the agent signs only the USDC transfer and the gateway pays the network fee. Wallet purchases are fee sponsored the same way when the response says fee_sponsored: true. The wallet needs only USDC in its own USDC account. ### Is there an MCP server? Yes, a local stdio MCP server in the mcp/ folder of the gateway repository, for Claude Desktop, Claude Code and other MCP clients. Its tools list models, check a balance, create a key, buy credits with Solana USDC (signing with a wallet you configure, or returning the transaction for you to sign) and chat. It is not published to npm; run it from a checkout with Node 22.18 or newer. ## Model pages - [Abliterated Large v2](https://inference.dagon.so/models/abliterated-model-large-v2): Abliterated Large v2 (abliterated-model-large-v2) on Dagon Inference: $1.10 input, $0.165 cached input, $2.20 output per 1M tokens, 1,048,576 token context, 3 providers. OpenAI compatible, paid in USDC. - [DeepSeek V4.1 Flash Abliterated](https://inference.dagon.so/models/deepseek-v4.1-flash-abliterated): DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated) on Dagon Inference: $0.132 input, $0.0275 cached input, $0.495 output per 1M tokens, 1,048,576 token context, 2 providers. OpenAI compatible, paid in USDC. - [GLM-5.3 Flash Abliterated](https://inference.dagon.so/models/glm-5.3-flash-abliterated): GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated) on Dagon Inference: $0.132 input, $0.044 cached input, $0.55 output per 1M tokens, 1,048,576 token context, 2 providers. OpenAI compatible, paid in USDC. - [Abliterated Large Flash](https://inference.dagon.so/models/abliterated-model-large-flash): Abliterated Large Flash (abliterated-model-large-flash) on Dagon Inference: $1.10 input, $0.11 cached input, $2.20 output per 1M tokens, 1,048,576 token context, 1 provider. OpenAI compatible, paid in USDC. - [Abliterated Model](https://inference.dagon.so/models/abliterated-model): Abliterated Model (abliterated-model) on Dagon Inference: $1.10 input, $0.11 cached input, $3.30 output per 1M tokens, 262,144 token context, 1 provider. OpenAI compatible, paid in USDC. ## Guides ### An uncensored LLM API for cybersecurity research URL: https://inference.dagon.so/cybersecurity-llm-api Dagon Inference gives you abliterated language models over an OpenAI or Anthropic compatible API. Abliterated models have their refusal behavior reduced or removed, so they answer more security questions than mainstream hosted models do; individual requests may still be declined or answered poorly. You pay per token in USDC, and the gateway does not log your prompts. #### Why do standard models refuse security work? Hosted assistants refuse a lot of legitimate security requests because the same text could serve an attacker: exploit analysis, shellcode, malware analysis detail. The refusal lands on defenders as often as on attackers. Abliteration reduces or removes the direction in the model's weights that drives those refusals. Individual requests may still be declined or answered poorly. It is still a language model: it can be wrong, so you check its output. #### What do security teams and researchers use it for? - Reverse engineering: explaining disassembly, decompiled functions and obfuscated scripts. - Vulnerability triage: reading a diff or advisory and reasoning about exploitability. - Code review and smart contract review: finding reentrancy, access control and accounting bugs before an auditor does. See the smart contract audit guide. - Defensive work: detection ideas, incident write ups and security training material. - Authorized red team preparation, under written authorization from the owner of the systems. - Capture the flag events and training. #### How good are these models at security tasks? We have not benchmarked them on security tasks and we do not publish claims we cannot show. They are general purpose models from abliteration.ai, Refuseless and Experiential Labs with context windows up to 1,048,576 tokens, which is enough to load a whole contract repository or a long binary analysis. Try a small request first; it costs well under a cent. Model | Model id | Input | Cached input | Output | Context | Providers | Abliterated Large v2 | abliterated-model-large-v2 | $1.10 | $0.165 | $2.20 | 1,048,576 | 3 | DeepSeek V4.1 Flash Abliterated | deepseek-v4.1-flash-abliterated | $0.132 | $0.0275 | $0.495 | 1,048,576 | 2 | GLM-5.3 Flash Abliterated | glm-5.3-flash-abliterated | $0.132 | $0.044 | $0.55 | 1,048,576 | 2 | Abliterated Large Flash | abliterated-model-large-flash | $1.10 | $0.11 | $2.20 | 1,048,576 | 1 | Abliterated Model | abliterated-model | $1.10 | $0.11 | $3.30 | 262,144 | 1 | Prices are per 1M tokens in USD at the cheapest provider serving each model, with the 10% markup included (15% on private leases). A request that falls back to another provider is billed at that provider's rate plus the markup; its receipt names the provider. Pinned to price version 2026-11-02.2. Live: /v1/models, also as JSON and Markdown. #### What can the gateway and its provider see? The gateway forwards your request to the cheapest healthy provider that serves the model: abliteration.ai, Refuseless or Experiential Labs. It does not write prompts or outputs to its database or logs; it keeps only the numbers: token counts, price and a SHA 256 of the output on a signed receipt. While a request is in transit, the gateway sees its content, your IP address and timing, and the provider sees its content and timing and the gateway's network address. 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. We cannot verify or control any of that. For a stronger separation between your payment and your usage, use a private lease. We do not monitor or log your content, and the acceptable use policy applies: use it lawfully and only against systems and people you own or have permission to test. We suspend keys that break it. #### How do you start? Create a key in the console, add USDC from $5, and point your SDK at https://inference.dagon.so/v1. The SDK guide has copy and paste code. **Is it legal to use an uncensored LLM for security research?** Whether a use is legal depends on where you are and what you do. We do not give legal advice. Computer misuse laws (for example the US CFAA and the UK Computer Misuse Act) apply to testing systems you do not own or lack written permission to test. Using a language model is not itself unlawful in most places. We do not monitor or log your content, and the acceptable use policy applies: use it lawfully and only against systems and people you own or have permission to test. We suspend keys that break it. **Does it keep my prompts?** The gateway does not store or log them: they pass through memory to the provider that serves the request (abliteration.ai, Refuseless or Experiential Labs). The database keeps keys, holds, credits and receipts (ids, token counts, prices and a SHA 256 of the output), not the text. 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. We cannot verify or control any of that. **Which models are available?** Abliterated Large v2 (abliterated-model-large-v2), DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated), GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated), Abliterated Large Flash (abliterated-model-large-flash) and Abliterated Model (abliterated-model). Model ids are neutral; a model is listed while at least one provider serving it is configured. Each request goes to the cheapest healthy provider serving that id and endpoint, with fallback to the next cheapest if it fails before any output; the receipt names the provider. Refuseless may route requests to other providers, so we cannot verify which model or deployment serves them. --- ### Audit smart contracts with an uncensored LLM URL: https://inference.dagon.so/smart-contract-audit-llm An abliterated LLM will reason about how a contract can be exploited instead of declining. Dagon Inference serves abliterated models with context windows up to 1,048,576 tokens, so you can load a full protocol, ask where funds can be drained, and pay per token in USDC. Use it on your own contracts or code in audit or bounty scope. Never against live protocols you are not authorized to test. #### Why do hosted models fail at contract auditing? Auditing is adversarial by nature. You ask the model to think like the attacker: how would you drain this vault, what happens on a donation attack, can this oracle be moved in one block. Mainstream models often answer with a refusal or a vague warning. An abliterated model is much less likely to, though individual requests may still be declined or answered poorly. Use it on your own contracts or code in audit or bounty scope. Never against live protocols you are not authorized to test. #### What can you ask it to do? - Walk through reentrancy, access control, rounding and share inflation risks in a Solidity or Vyper contract. - Draft a Foundry or Hardhat test that reproduces a suspected bug on a local fork. - Review a Solana program for missing signer, owner and account checks. - Explain a past exploit and check whether your code has the same shape. Treat the output as a lead, not a finding. Confirm every claim with a test before you act on it, and never rely on a model as your only review. #### How much does an audit pass cost? Reading a large repository is mostly input tokens. On Abliterated Large Flash, input costs $1.10 per 1M tokens and cached input $0.11, so a 200,000 token codebase costs about $0.22 to read once, less when the prefix is cached on repeat questions. Output is $2.20 per 1M tokens. Every request is held against your balance first, so a long run cannot overspend. See the pricing page for the full table and a worked example. #### Can a crypto team pay without an account? A key needs no email or password, and you fund it in USDC. To separate payment from usage, use a private zkAPI lease. We do not monitor or log your content, and the acceptable use policy applies: use it lawfully and only against systems and people you own or have permission to test. We suspend keys that break it. **Can an LLM replace a smart contract audit?** No. It speeds up the first pass and helps you write tests. A human audit and your own tests remain the standard. **Which chains does it understand?** The models read any code you paste, including Solidity, Vyper, Rust for Solana and Move. Quality varies by language and we have not benchmarked each. --- ### Pay for an LLM API with USDC URL: https://inference.dagon.so/pay-for-llm-api-with-usdc With Dagon Inference you create an API key with one request, fund it with USDC through hosted checkout from $5 to $1,000, and pay only for the tokens each request uses. Creating a key asks for no email or password, and there is no subscription. #### How does paying in USDC work? - Create a key: curl -X POST https://inference.dagon.so/v1/keys returns a gk_ key. No email, no password. - Ask for a checkout link: POST https://inference.dagon.so/v1/credits/checkout with the amount in dollars. - Pay USDC on the hosted page. You can also pay from another chain that Circle CCTP supports. - The credit posts when the payment settles, and requests start drawing it down. You can do all of this in the console instead. #### Can an agent pay per request without a key? Yes, with x402 (versions 1 and 2, exact scheme, USDC on Solana mainnet). Send the request with no key and the API answers 402 with the payment requirements: the usual error object plus x402Version and accepts in the body, and the v2 requirements in the PAYMENT-REQUIRED header. The amount is the request's maximum cost, at least $0.5, paid to our treasury 9rMdbu4KdLWH2nPXbzhm9HTKaibGZ2ckakQbW1wPh6KK in USDC. Your client signs a USDC TransferChecked to the treasury, with the gateway's fee payer from extra.feePayer so you need no SOL, and repeats the request with it in X-PAYMENT or PAYMENT-SIGNATURE. The gateway checks the transaction, screens the paying wallet against the OFAC sanctions list, settles it on chain and answers the request. The paid response returns the transaction in X-PAYMENT-RESPONSE and a new gk_ key in x-dagon-key holding what the request did not spend; use that key for the next requests. A key that runs low gets a 402 asking for a top-up of at least $1, credited to that key. Each transaction is credited once. ``` import { wrapFetchWithPaymentFromConfig } from "@x402/fetch"; import { ExactSvmScheme, toClientSvmSigner } from "@x402/svm"; import { createKeyPairSignerFromBytes } from "@solana/kit"; const wallet = await createKeyPairSignerFromBytes(secretKey); // a wallet holding USDC const pay = wrapFetchWithPaymentFromConfig(fetch, { schemes: [{ network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", client: new ExactSvmScheme(toClientSvmSigner(wallet)) }], }); const res = await pay("https://inference.dagon.so/v1/chat/completions", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ model: "abliterated-model-large-flash", messages: [{ role: "user", content: "Hi" }], max_tokens: 200 }), }); const key = res.headers.get("x-dagon-key"); // keep it: it holds the rest ``` The v1 clients x402-fetch and x402-axios work too, with createSigner("solana", privateKey). The x402 guide has the full 402 response, a Python client, the limits and every error code. #### What does it cost? The token price of the provider that serves the request plus our 10% markup, billed in whole millionths of a dollar. There are no seats and no minimum spend beyond the $5 top up. Full numbers are on the pricing page. #### Can I give separate keys to agents or teammates? Yes. Sign in to the console with a passkey, add USDC to your account balance, then mint a key for each agent, script or teammate and fund each with a set amount. You can add funds, take unspent money back, or delete a key and the balance returns to you. A lost or leaked key is replaced in seconds. Keys under one account can be linked to each other, and balances are prepaid credits held by the service. #### How do you know you were charged correctly? Every request gets an Ed25519 signed receipt with the token counts, price version, markup and charge. The console verifies it in your browser, and anyone can redo the arithmetic against the gateway's public key at /v1/identity. #### Is there a way to pay without linking a wallet to usage? Yes: private leases from a zkAPI server. The prepaid key path links the paying wallet to the key it funds. **Which chains can I pay from?** Hosted checkout takes USDC. It also offers paying from other EVM chains that Circle CCTP V2 supports. **How do I know the checkout page is genuine?** Our checkout runs only at https://pay.dagon.so, and you reach it only from a top up you start. Before you approve, check that the amount matches the one you chose and that the destination matches, in full, the treasury or contract address listed on official domains and payment addresses. We never ask you to pay by direct message, ad or a link we did not generate. **What if I lose my key?** It is lost, with its balance. We store only a hash, so we cannot show a key again and cannot verify who owns one; we do not recover, transfer or refund a lost key. Save it in a password manager the moment it is created. Keys minted under a passkey account can be replaced. **Do credits expire?** From 2026-11-27, we may expire credits that remain unused 365 days after the top up that bought them, except where the law requires otherwise. Keep your key secret; it is a bearer credential and is shown once. **What is the largest top up?** $1,000 per top up, and the smallest is $5. **Can I pay with x402?** Yes, on the inference endpoints, in USDC on Solana mainnet. The 402 response lists the amount, the treasury and the fee payer; the paid response returns a prepaid key holding the unspent rest. Standard x402 clients such as @x402/fetch with @x402/svm handle it. --- ### A private LLM API with zkAPI leases URL: https://inference.dagon.so/private-llm-api-zkapi A private lease is a spend limited key (lk_) minted by a zkAPI server against a deposit that the gateway never learns about. You use it like any API key, up to $10 and 24 hours per lease, so your payment is not tied to your usage. #### What problem does a lease solve? With a prepaid key, the wallet that pays is linked to the key it funds. A lease breaks that link: the deposit is proven with a zero knowledge proof, and the gateway sees only a key with a limit. #### What does the gateway still see? Be clear about the limits. The gateway and the model provider that serves the request still see request content, IP addresses and timing in transit, and requests made with one lease can be linked to each other. A lease hides who paid, not what you sent. Use a VPN or Tor if your network address matters. #### What does it cost? Leases pay 15% over the serving provider's price: the 10% markup plus 5% for the swap from SOL to USDC. Each lease is capped at $10 and 24 hours by the gateway. #### How do you get one? Run a zkAPI client against a server that points at this gateway, then use the returned lk_ key as the bearer token on https://inference.dagon.so/v1. The console has a Private access page with the details. We do not monitor or log your content, and the acceptable use policy applies: use it lawfully and only against systems and people you own or have permission to test. We suspend keys that break it. **Is a lease fully anonymous?** No. It separates payment from usage. Content, IP and timing are still visible in transit, as above. **Can I top up a lease?** A lease has a fixed limit. Mint another when it runs out. --- ### Use an uncensored LLM with the OpenAI SDK URL: https://inference.dagon.so/uncensored-llm-openai-sdk Change the base URL of your OpenAI or Anthropic SDK to https://inference.dagon.so/v1 and use a Dagon Inference key. Chat Completions, Responses and Messages all work, including streaming, so existing tools and agents keep running. #### What does the code look like? ``` import OpenAI from "openai"; const client = new OpenAI({ baseURL: "https://inference.dagon.so/v1", apiKey: process.env.DAGON_KEY, }); const reply = await client.chat.completions.create({ model: "abliterated-model-large-flash", messages: [{ role: "user", content: "Explain this stack trace." }], }); ``` For the Anthropic SDK, set the base URL to https://inference.dagon.so without /v1 and call Messages as usual. Any tool that accepts an OpenAI or Anthropic compatible endpoint works, including coding agents. #### Which model ids can I use? Use these exact ids; other names are rejected. Model | Model id | Input | Cached input | Output | Context | Providers | Abliterated Large v2 | abliterated-model-large-v2 | $1.10 | $0.165 | $2.20 | 1,048,576 | 3 | DeepSeek V4.1 Flash Abliterated | deepseek-v4.1-flash-abliterated | $0.132 | $0.0275 | $0.495 | 1,048,576 | 2 | GLM-5.3 Flash Abliterated | glm-5.3-flash-abliterated | $0.132 | $0.044 | $0.55 | 1,048,576 | 2 | Abliterated Large Flash | abliterated-model-large-flash | $1.10 | $0.11 | $2.20 | 1,048,576 | 1 | Abliterated Model | abliterated-model | $1.10 | $0.11 | $3.30 | 262,144 | 1 | Prices are per 1M tokens in USD at the cheapest provider serving each model, with the 10% markup included (15% on private leases). A request that falls back to another provider is billed at that provider's rate plus the markup; its receipt names the provider. Pinned to price version 2026-11-02.2. Live: /v1/models, also as JSON and Markdown. #### Does it support streaming and images? Streaming is supported. Abliterated Large Flash and Abliterated Model accept image input; Abliterated Large v2, DeepSeek V4.1 Flash Abliterated and GLM-5.3 Flash Abliterated are text only. The default output cap is 16,384 tokens and the maximum is 65,536. #### What happens if a request fails halfway? If the upstream fails or is unreachable before it accepts the request, or reports an error before any output, the charge is zero. A zero receipt is still signed when the request was accepted. If usage is not reported or the stream is cut off, you pay an estimate: the estimated prompt plus the text streamed so far. That estimate can be higher than the real cost. **Do I need to change my code beyond the base URL?** No. Keep the SDK, swap the base URL and key, and set the model id. **Where do I get a key?** Create one in the console or with POST https://inference.dagon.so/v1/keys. No email needed. --- ### Abliterated LLM API pricing URL: https://inference.dagon.so/abliterated-llm-pricing Dagon Inference serves 5 uncensored (abliterated) models, from $0.132 input and $0.495 output per million tokens on DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated) up to $1.10 input and $3.30 output on Abliterated Model (abliterated-model). Each price is the token price of the cheapest provider serving the model plus 10% (15% on private leases), billed per request in whole millionths of a dollar. There is no subscription, no seat fee and no minimum spend. #### What does each model cost per million tokens? Model | Model id | Input | Cached input | Output | Context | Providers | Abliterated Large v2 | abliterated-model-large-v2 | $1.10 | $0.165 | $2.20 | 1,048,576 | 3 | DeepSeek V4.1 Flash Abliterated | deepseek-v4.1-flash-abliterated | $0.132 | $0.0275 | $0.495 | 1,048,576 | 2 | GLM-5.3 Flash Abliterated | glm-5.3-flash-abliterated | $0.132 | $0.044 | $0.55 | 1,048,576 | 2 | Abliterated Large Flash | abliterated-model-large-flash | $1.10 | $0.11 | $2.20 | 1,048,576 | 1 | Abliterated Model | abliterated-model | $1.10 | $0.11 | $3.30 | 262,144 | 1 | Prices are per 1M tokens in USD at the cheapest provider serving each model, with the 10% markup included (15% on private leases). A request that falls back to another provider is billed at that provider's rate plus the markup; its receipt names the provider. Pinned to price version 2026-11-02.2. Live: /v1/models, also as JSON and Markdown. #### What does one request cost? Worked example on Abliterated Large Flash: a 1,200 character prompt, 412 input tokens (256 cached) and 238 output tokens costs 724 µ$, which is $0.000724. Before sending, the gateway holds $0.037446 against your balance, covering the prompt estimate plus your output cap. When the upstream reports usage, the held amount beyond the charge, $0.036722, returns to your balance. #### What if the stream drops or the upstream fails? If the upstream fails or is unreachable before it accepts the request, or reports an error before any output, you pay nothing. If you disconnect mid stream you pay for the estimated prompt plus what streamed. Each outcome has its own signed receipt. If usage is not reported or a request is cut off, you pay an estimate, which can be higher than the real cost. #### How do I pay? In USDC from $5, as covered in paying for an LLM API with USDC, or through a private lease, which separates payment from usage. **Which uncensored models does Dagon Inference serve?** Abliterated Large v2 (abliterated-model-large-v2), DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated), GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated), Abliterated Large Flash (abliterated-model-large-flash) and Abliterated Model (abliterated-model). All are abliterated or uncensored builds with refusal behavior reduced or removed, served over OpenAI compatible endpoints, and Anthropic Messages where the provider supports it. The live list is GET https://inference.dagon.so/v1/models. **What does Abliterated Large v2 cost per million tokens?** $1.10 input, $0.165 cached input and $2.20 output per 1M tokens (model id abliterated-model-large-v2), including the 10% markup, at price version 2026-11-02.2. Context window: 1,048,576 tokens. **What does DeepSeek V4.1 Flash Abliterated cost per million tokens?** $0.132 input, $0.0275 cached input and $0.495 output per 1M tokens (model id deepseek-v4.1-flash-abliterated), including the 10% markup, at price version 2026-11-02.2. Context window: 1,048,576 tokens. **What does GLM-5.3 Flash Abliterated cost per million tokens?** $0.132 input, $0.044 cached input and $0.55 output per 1M tokens (model id glm-5.3-flash-abliterated), including the 10% markup, at price version 2026-11-02.2. Context window: 1,048,576 tokens. **What does Abliterated Large Flash cost per million tokens?** $1.10 input, $0.11 cached input and $2.20 output per 1M tokens (model id abliterated-model-large-flash), including the 10% markup, at price version 2026-11-02.2. Context window: 1,048,576 tokens. **What does Abliterated Model cost per million tokens?** $1.10 input, $0.11 cached input and $3.30 output per 1M tokens (model id abliterated-model), including the 10% markup, at price version 2026-11-02.2. Context window: 262,144 tokens. **Is there a free tier?** No free tier. The smallest top up is $5, and a typical short request costs a fraction of a cent. **Why is cached input cheaper?** Providers bill repeated prompt prefixes they have cached at a lower rate, shown per model in the table, which makes long repeated contexts like a codebase cheap to re-read. --- ### Buy credits from an agent (wallet) URL: https://inference.dagon.so/buy-llm-credits-from-an-agent-wallet An agent with a Solana wallet can fund its own key without a browser. POST https://inference.dagon.so/v1/credits/purchase returns an unsigned USDC transaction for that wallet; the agent signs it, sends it to Solana, and calls POST https://inference.dagon.so/v1/credits/purchase/confirm, which credits the key once the payment is final. No email is asked, and the private key never leaves the agent. #### How does a wallet purchase work? - POST /v1/credits/purchase with Authorization: Bearer gk_... (the key to fund) and {"amount_usd": 20, "payer_wallet": "", "chain": "solana"}. The answer has purchase_id, amount_total, currency (usdc), unsigned_transaction (base64), blockhash, last_valid_block_height, fee_sponsored, expires_at and confirm_url. - Deserialize the transaction, sign it with the wallet and send it to Solana. It moves exactly amount_total USDC from the wallet to our treasury, with the purchase id in a memo. Its blockhash expires about a minute after step 1; if it does, call step 1 again. - POST /v1/credits/purchase/confirm with {"purchase_id": "...", "signature": ""}. The payment service waits for the transaction to finalize, which can take up to about 45 seconds, then the key is credited and the answer is {"status": "credited", "credited_usd": 20, "balance": ...}. A 202 with {"status": "pending"} means it is not final yet: call confirm again after retry_after_s. Confirm is safe to repeat. GET /v1/credits/purchase/{purchase_id} reads the status at any time: open (awaiting payment), credited, expired, refused or pending. Top ups are $5 to $1,000 in whole cents. #### Does the wallet need SOL? Not when fee_sponsored is true. Then the transaction's fee payer is our checkout fee payer, which has already signed it and pays the network fee and any account rent; the wallet signs only as the owner of the USDC. Keep that signature: sign with the wallet alone, as the scripts below do, without rebuilding the transaction or changing its fee payer. When fee_sponsored is false, the wallet is the fee payer and needs a little SOL: the network fee (5,000 lamports per signature), plus rent if our treasury's USDC account had to be created. Either way the wallet must hold the USDC in its own USDC token account, and it must be a key pair that can sign, not a program address such as a multisig vault. A fee-sponsored purchase may also send {"purchase_id", "signed_transaction"} (base64) to confirm instead of a signature, and the payment service broadcasts it. #### TypeScript (@solana/web3.js) ``` // npm install @solana/web3.js then: node buy-credits.ts (Node 24) or npx tsx buy-credits.ts import { readFileSync } from "node:fs"; import { setTimeout as sleep } from "node:timers/promises"; import { Connection, Keypair, VersionedTransaction } from "@solana/web3.js"; const API = "https://inference.dagon.so/v1"; const KEY = process.env.DAGON_KEY; // the gk_ key to fund // A solana-keygen JSON keypair file. const wallet = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(readFileSync(process.env.SOLANA_KEYPAIR ?? "", "utf8")))); const rpc = new Connection(process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com", "confirmed"); async function call(path: string, body: object) { const res = await fetch(`${API}${path}`, { method: "POST", headers: { authorization: `Bearer ${KEY}`, "content-type": "application/json" }, body: JSON.stringify(body), }); const json = await res.json(); if (!res.ok) throw new Error(`${res.status} ${json.error?.code}: ${json.error?.message}`); return { status: res.status, json }; } // 1. Open the purchase: the gateway returns the USDC transaction for this wallet. const { json: p } = await call("/credits/purchase", { amount_usd: 20, payer_wallet: wallet.publicKey.toBase58(), chain: "solana" }); // 2. Sign as the wallet (a fee-sponsored transaction keeps the fee payer's signature) and send it. const tx = VersionedTransaction.deserialize(Buffer.from(p.unsigned_transaction, "base64")); tx.sign([wallet]); const signature = await rpc.sendRawTransaction(tx.serialize()); await rpc.confirmTransaction({ signature, blockhash: p.blockhash, lastValidBlockHeight: p.last_valid_block_height }, "confirmed"); // 3. Confirm: the key is credited once the payment is final. 202 means not yet: ask again. for (;;) { const { status, json } = await call("/credits/purchase/confirm", { purchase_id: p.purchase_id, signature }); if (status === 200) { console.log(`credited $${json.credited_usd}, balance $${json.balance}`); break; } await sleep((json.retry_after_s ?? 5) * 1000); } ``` Set DAGON_KEY, SOLANA_KEYPAIR (path to the wallet's keypair file) and, optionally, SOLANA_RPC_URL. #### Python (solders and solana-py) ``` # pip install solders solana httpx then: python buy_credits.py import asyncio, base64, json, os import httpx from solana.rpc.async_api import AsyncClient from solders.keypair import Keypair from solders.message import to_bytes_versioned from solders.transaction import VersionedTransaction API = "https://inference.dagon.so/v1" KEY = os.environ["DAGON_KEY"] # the gk_ key to fund with open(os.environ["SOLANA_KEYPAIR"]) as f: # a solana-keygen JSON keypair file wallet = Keypair.from_bytes(bytes(json.load(f))) async def call(http, path, body): r = await http.post(f"{API}{path}", json=body, headers={"Authorization": f"Bearer {KEY}"}, timeout=120) if r.status_code >= 400: err = r.json()["error"] raise SystemExit(f"{r.status_code} {err['code']}: {err['message']}") return r.status_code, r.json() async def main(): rpc_url = os.environ.get("SOLANA_RPC_URL", "https://api.mainnet-beta.solana.com") async with httpx.AsyncClient() as http, AsyncClient(rpc_url) as rpc: # 1. Open the purchase: the gateway returns the USDC transaction for this wallet. _, p = await call(http, "/credits/purchase", {"amount_usd": 20, "payer_wallet": str(wallet.pubkey()), "chain": "solana"}) # 2. Sign as the wallet, keeping the fee payer's signature on a fee-sponsored transaction, and send it. tx = VersionedTransaction.from_bytes(base64.b64decode(p["unsigned_transaction"])) signers = list(tx.message.account_keys)[: tx.message.header.num_required_signatures] sigs = list(tx.signatures) sigs[signers.index(wallet.pubkey())] = wallet.sign_message(to_bytes_versioned(tx.message)) tx = VersionedTransaction.populate(tx.message, sigs) sig = (await rpc.send_raw_transaction(bytes(tx))).value await rpc.confirm_transaction(sig, "confirmed", last_valid_block_height=p["last_valid_block_height"]) # 3. Confirm: the key is credited once the payment is final. 202 means not yet: ask again. while True: status, r = await call(http, "/credits/purchase/confirm", {"purchase_id": p["purchase_id"], "signature": str(sig)}) if status == 200: print(f"credited ${r['credited_usd']}, balance ${r['balance']}") return await asyncio.sleep(r.get("retry_after_s", 5)) asyncio.run(main()) ``` #### What can go wrong? - 400 invalid_wallet: payer_wallet is not a Solana wallet address that can sign. - 400 amount_out_of_range or invalid_amount: outside $5 to $1,000, or not whole cents. - 403 payment_refused: the wallet is on the OFAC sanctions list. A payment sent from one anyway is held, not credited. - 451 location_blocked: the request comes from a location where the service is not offered. The check uses the agent's address, not the gateway's. - 400 payment_not_verified: the signature is not a payment of this purchase (wrong amount, failed transaction, or already used). - 429: too many purchases or open purchases on one key; see Retry-After. Before you approve anything, you can check the treasury address the transaction pays against official domains and payment addresses. #### Can an agent pay without a key at all? Yes: with x402 pay per request an agent sends the model request with no key, gets a 402 with the price, and retries with a signed USDC transfer. The first paid response returns a key in x-dagon-key; from then on the agent can top that key up with the purchase calls above, or keep paying per request. Use the purchase when you want to load a balance once; use x402 when the agent should pay as it goes. **Is an email or account needed?** No. The key itself authorizes the purchase, and the purchase asks for no email. **Can an agent pay from another chain?** The one-shot purchase is Solana only. The hosted checkout from POST /v1/credits/checkout also takes USDC from other chains that Circle CCTP supports, but needs a browser wallet. **Does the gateway see the wallet's private key?** No. The transaction is signed where the agent runs; the gateway and the payment service only ever see the public address and the signed transaction. --- ### Pay-per-request LLM API with x402 (USDC on Solana) URL: https://inference.dagon.so/x402-llm-api Send a request to https://inference.dagon.so/v1/chat/completions, /v1/responses or /v1/messages with no API key. The gateway answers 402 Payment Required with x402 payment requirements (versions 1 and 2, exact scheme, USDC on Solana mainnet). Your agent signs a USDC transfer, repeats the request with it in X-PAYMENT or PAYMENT-SIGNATURE, and gets the model's answer plus a prepaid key in x-dagon-key that holds whatever the request did not spend. No account, no email, and no SOL: the gateway pays the network fee. A small request costs at least $0.5; one payment can be at most $1,000. #### How does the x402 flow work? - Send the request as usual, without Authorization. The gateway validates it and prices its maximum cost (prompt estimate plus output cap), then answers 402 with code payment_required. The body keeps the usual OpenAI or Anthropic error object and adds the x402 v1 fields x402Version and accepts; the PAYMENT-REQUIRED header carries the same requirements as x402 v2 (base64 JSON). - Your client signs, but does not send, a Solana transaction: one SPL Token TransferChecked of the stated amount of USDC from the wallet's own USDC account to the treasury 9rMdbu4KdLWH2nPXbzhm9HTKaibGZ2ckakQbW1wPh6KK (USDC account E6dUxbCSJ3ygHSuT5DrjLDJediPzHiKQy2nJHb115nfg), with extra.feePayer as the fee payer. - It repeats the same request with the base64 payment payload in X-PAYMENT (v1) or PAYMENT-SIGNATURE (v2). - The gateway checks the transaction, refuses blocked locations, screens the paying wallet against the OFAC SDN list, co-signs as fee payer, simulates, broadcasts and waits for confirmation (usually seconds), then serves the request from the payment. - The response carries PAYMENT-RESPONSE and X-PAYMENT-RESPONSE (base64 JSON with success, transaction, network, payer, amount), x-dagon-transaction (the signature) and, for a keyless payment, x-dagon-key. Standard x402 clients do all of this for you: @x402/fetch or @x402/axios with @x402/svm, the Python x402 package, or the v1 x402-fetch and x402-axios. #### What does the 402 response look like? This is the answer to a small keyless chat request (its maximum cost is under the minimum, so the minimum of $0.5, 500000 USDC base units, is asked). On /v1/messages the error object has the Anthropic shape instead. ``` HTTP/1.1 402 Payment Required Content-Type: application/json PAYMENT-REQUIRED: eyJ4NDAyVmVyc2lvbiI6Mi... (base64 JSON, below) Link: ; rel="terms-of-service" Cache-Control: no-store { "x402Version": 1, "accepts": [{ "scheme": "exact", "network": "solana", "maxAmountRequired": "500000", "resource": "https://inference.dagon.so/v1/chat/completions", "description": "One abliterated-model-large-flash request on Dagon, prepaid at its maximum cost. The unspent rest stays as credit on the key returned once in x-dagon-key and is not refunded; reuse that key. Terms: https://inference.dagon.so/terms", "mimeType": "application/json", "payTo": "9rMdbu4KdLWH2nPXbzhm9HTKaibGZ2ckakQbW1wPh6KK", "maxTimeoutSeconds": 60, "asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "extra": { "feePayer": "4UZVmNWoetLmDeQnfFFCYrFuN7epN6WgchiDxJ6VVA52" } }], "error": { "message": "Pay for this request with x402 (USDC on Solana; requirements in `accepts` and the PAYMENT-REQUIRED header), or send an API key as 'Authorization: Bearer '.", "type": "billing_error", "param": null, "code": "payment_required" } } ``` Decoded, the PAYMENT-REQUIRED header is the x402 v2 object: ``` { "x402Version": 2, "error": "Pay for this request with x402 ...", "resource": { "url": "https://inference.dagon.so/v1/chat/completions", "description": "One abliterated-model-large-flash request on Dagon, ...", "mimeType": "application/json" }, "accepts": [{ "scheme": "exact", "network": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", "amount": "500000", "asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "payTo": "9rMdbu4KdLWH2nPXbzhm9HTKaibGZ2ckakQbW1wPh6KK", "maxTimeoutSeconds": 60, "extra": { "feePayer": "4UZVmNWoetLmDeQnfFFCYrFuN7epN6WgchiDxJ6VVA52" } }] } ``` Amounts are USDC base units (millionths of a dollar). The fee payer above is the production one; it is also listed on official domains and payment addresses. Check the treasury in full against official domains and payment addresses before your agent signs anything. #### TypeScript (@x402/fetch and @x402/svm) ``` // npm install @x402/fetch @x402/svm @solana/kit import { readFileSync } from "node:fs"; import { wrapFetchWithPaymentFromConfig } from "@x402/fetch"; import { ExactSvmScheme, toClientSvmSigner } from "@x402/svm"; import { createKeyPairSignerFromBytes } from "@solana/kit"; // A solana-keygen JSON keypair file for a wallet holding USDC (no SOL needed). const secret = Uint8Array.from(JSON.parse(readFileSync(process.env.SOLANA_KEYPAIR ?? "", "utf8"))); const signer = toClientSvmSigner(await createKeyPairSignerFromBytes(secret)); const pay = wrapFetchWithPaymentFromConfig(fetch, { schemes: [{ network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", client: new ExactSvmScheme(signer) }], }); const res = await pay("https://inference.dagon.so/v1/chat/completions", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ model: "abliterated-model-large-flash", messages: [{ role: "user", content: "Hi" }], max_tokens: 200 }), }); const reply = await res.json(); console.log(reply.choices?.[0]?.message?.content ?? reply.error); // Keep this key: it holds what the request did not spend. Send it as a Bearer key next time. const key = res.headers.get("x-dagon-key"); ``` The wrapper reads the 402, signs the transfer with the wallet and retries once. For streaming, set "stream": true as usual; the stream starts after the payment confirms. #### Python (x402 with httpx) ``` # pip install "x402[httpx,svm]" then: python pay_per_request.py import asyncio import os from x402 import x402Client from x402.http.clients import x402HttpxClient from x402.mechanisms.svm import KeypairSigner from x402.mechanisms.svm.exact.register import register_exact_svm_client async def main(): # Refuse any single payment above $1; raise it for large requests. client = x402Client().set_spend_controls({"max_amount_per_payment": "$1"}) # Base58 secret key of a wallet holding USDC (no SOL needed). register_exact_svm_client(client, KeypairSigner.from_base58(os.environ["SOLANA_PRIVATE_KEY"])) # Settlement waits for Solana confirmation: allow a long timeout. async with x402HttpxClient(client, timeout=120) as http: r = await http.post("https://inference.dagon.so/v1/chat/completions", json={ "model": "abliterated-model-large-flash", "messages": [{"role": "user", "content": "Hi"}], "max_tokens": 200, }) await r.aread() print(r.status_code, r.json()) # Keep this key: it holds what the request did not spend. print("x-dagon-key:", r.headers.get("x-dagon-key")) asyncio.run(main()) ``` Any OpenAI or Anthropic SDK works for the requests after the first: pass the key from x-dagon-key as the API key and the base URL https://inference.dagon.so/v1. #### Why reuse the key in x-dagon-key? A keyless payment buys the request's maximum cost, at least $0.5. What the request does not spend stays as credit on a gk_ prepaid key, returned once in x-dagon-key. It is not refunded to the wallet, so keep the key and send it as Authorization: Bearer gk_... (or x-api-key) on the next requests: they draw that balance down and need no payment. The key is tied to the paying wallet: every keyless payment from one wallet credits the same key and returns the same secret, so an agent that loses the header gets the key again with its next keyless payment. When the key runs short, the gateway answers 402 insufficient_credits asking for a top-up of at least $1 (or the shortfall, if larger); pay it with the key still in Authorization and that key is credited. Lease keys (lk_) cannot be topped up this way. #### Does my agent need SOL? No. The 402 names the gateway's fee payer in extra.feePayer. Your agent builds the transaction with that address as fee payer and signs only as the owner of the USDC; the gateway adds the fee payer's signature and pays the network fee. The wallet needs USDC in its own USDC token account and nothing else. To keep the sponsored fee bounded, a sponsored payment may set at most 200,000 compute units and a priority price of at most 50,000 microlamports per unit, and the fee payer may not appear in any instruction. #### What are the limits? - Keyless request: pays its maximum cost, at least $0.5. Top-up of a key: the shortfall, at least $1. - One payment: at most $1,000, and at most $0.01 over the stated amount. - Per key: at most $2,000 of paid credit in any 24 hours, across x402, wallet purchases and checkout. - The transaction: legacy or version 0, no address lookup tables, at most 7 instructions, only compute budget, one USDC TransferChecked, and memo or wallet-added Lighthouse instructions; the transfer authority must be a key pair that signs (no multisig). - Each transaction is credited once, and never also to a checkout. - Solana mainnet only. For other chains, use hosted USDC checkout. #### Where is x402 payment refused? Payments are checked before anything is signed or broadcast. A request from a location where the service is not offered gets 451 location_blocked; the check uses the caller's IP address. A transaction signed by a wallet on the OFAC SDN list gets 403 payment_refused, nothing is broadcast, and a key being topped up is disabled. While the location table or the sanctions list is loading, payments get 503 with Retry-After. We do not monitor or log your content, and the acceptable use policy applies: use it lawfully and only against systems and people you own or have permission to test. We suspend keys that break it. #### Troubleshooting by error code - 402 payment_required: no key and no payment. Pay what accepts asks, or send a key. - 402 insufficient_credits: the key is short of this request's maximum cost. Pay the top-up in accepts, lower max_tokens, or fund the key another way. - 402 invalid_exact_svm_payload_amount_mismatch: the transfer is below the amount, more than $0.01 over it, or over $1,000. Sign a new payment for exactly the stated amount. - 402 invalid_exact_svm_payload_recipient_mismatch or _mint_mismatch: pay USDC (EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v) to the treasury's USDC account. - 402 invalid_exact_svm_payload_transaction_fee_payer_transferring_funds, _excessive_signers, _instructions_compute_limit_instruction_too_high, _compute_price_instruction_too_high: build the transaction as the x402 SDKs do, with extra.feePayer as fee payer only. - 402 invalid_exact_svm_smart_wallet_alt_resolution_not_available: address lookup tables are not accepted. - 402 invalid_exact_svm_transaction_simulation_failed: usually not enough USDC, or no USDC token account. The PAYMENT-RESPONSE header has the reason. - 402 invalid_exact_svm_transaction_failed: it failed on chain or expired before landing. Sign a new payment with a recent blockhash. - 402 duplicate_settlement: this transaction was already presented. Sign a new one. - 402 settlement_pending: broadcast but not confirmed in time. Retry the same request with the same payment header and the key from x-dagon-key after Retry-After; it is credited once it lands. - 402 paid_daily_cap_exceeded: the key received $2,000 of paid credit in the last 24 hours. Try later. - 400 invalid_exact_svm_payload_transaction_could_not_be_decoded, _unsupported_scheme, _network_mismatch: the header is not a base64 x402 payload for exact on Solana mainnet. - 400 not_topup_key: lease keys cannot be topped up with x402. - 403 payment_refused, 451 location_blocked: see above. 503 payment_unavailable, sanctions_unavailable, geo_unavailable: try again after Retry-After; nothing was charged. #### What are the other ways an agent can pay? - x402 per request (this page): no key, no setup, pays as it goes. - Wallet top-up in two calls: POST /v1/credits/purchase returns a USDC transaction, the agent signs and sends it, and POST /v1/credits/purchase/confirm credits the key. See buy credits from an agent wallet. - MCP server: the mcp/ folder of the gateway repository is a local stdio MCP server with tools to list models, create a key, buy credits from a wallet and chat. It is not published to npm; run it from a checkout. A person paying with a browser wallet uses hosted USDC checkout instead. **Can an AI agent pay for LLM API calls itself?** Yes. With x402 an agent that controls a Solana wallet holding USDC pays for each request inside the HTTP exchange: no account, email, browser or API key. The first paid response returns a prepaid key the agent can keep using. **Which x402 versions, schemes and networks are supported?** x402 versions 1 and 2, the exact scheme, USDC on Solana mainnet (solana in v1, solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp in v2). Other chains and tokens are not accepted over x402. **Is a facilitator involved?** No. The gateway verifies and settles payments itself, so the location check and the OFAC screen run before anything is signed. Clients need no facilitator configuration. **Is the unspent amount refunded?** No. It stays as credit on the key returned in x-dagon-key, which the same wallet gets back on every keyless payment. Spend it by sending that key. **Which models can I pay for this way?** Every listed model: abliterated-model-large-v2, deepseek-v4.1-flash-abliterated, glm-5.3-flash-abliterated, abliterated-model-large-flash and abliterated-model. Prices are on the pricing page and at GET https://inference.dagon.so/v1/models. --- ### Abliterated Large v2 URL: https://inference.dagon.so/models/abliterated-model-large-v2 abliterated-model-large-v2 is Abliterated Large v2, an abliterated model with refusal behavior reduced or removed, served by Dagon Inference over an OpenAI compatible API and the Anthropic Messages API. It costs $1.10 per million input tokens, $0.165 per million cached input tokens and $2.20 per million output tokens, with a 1,048,576 token context window, up to 65,536 output tokens per request and text input only. 3 providers serve it: abliteration.ai, Refuseless and Experiential Labs. #### What does Abliterated Large v2 cost? Tokens | Price per 1M | Input | $1.10 | Cached input | $0.165 | Output | $2.20 | A request with 10,000 input tokens and 1,000 output tokens costs 13,200 µ$, about $0.0132. Prices are Refuseless's, the cheapest provider serving this model, plus the 10% markup (15% on private leases), at price version 2026-11-02.2. A request that falls back to another provider is billed at that provider's rate plus the markup; its signed receipt names the provider. Every model: pricing, models.json, live /v1/models. #### What is it? Flagship large model, text only, 1M context. - Model id: abliterated-model-large-v2 - Context window: 1,048,576 tokens - Maximum output: 65,536 tokens per request (default cap 16,384) - Input: text input only - Endpoints: /v1/chat/completions, /v1/responses, /v1/messages - Providers: abliteration.ai, Refuseless and Experiential Labs We have not benchmarked it and make no claims about its quality. Individual requests may still be declined or answered poorly. #### How do I call it? Create a key with curl -X POST https://inference.dagon.so/v1/keys or in the console, fund it in USDC, then: ``` curl https://inference.dagon.so/v1/chat/completions \ -H "Authorization: Bearer $DAGON_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "abliterated-model-large-v2", "messages": [{"role": "user", "content": "Hello"}]}' ``` With an OpenAI SDK, set the base URL to https://inference.dagon.so/v1 and the model to abliterated-model-large-v2. With an Anthropic SDK, use https://inference.dagon.so as the base URL. The SDK guide has more examples. #### Other models - DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated): $0.132 input, $0.495 output per 1M tokens - GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated): $0.132 input, $0.55 output per 1M tokens - Abliterated Large Flash (abliterated-model-large-flash): $1.10 input, $2.20 output per 1M tokens - Abliterated Model (abliterated-model): $1.10 input, $3.30 output per 1M tokens **What does Abliterated Large v2 cost per million tokens?** $1.10 per million input tokens, $0.165 per million cached input tokens and $2.20 per million output tokens (model id abliterated-model-large-v2), including the 10% markup, at price version 2026-11-02.2. **What is the context window of Abliterated Large v2?** 1,048,576 tokens, with up to 65,536 output tokens per request through Dagon Inference. **Which providers serve abliterated-model-large-v2?** abliteration.ai, Refuseless and Experiential Labs. Each request goes to the cheapest healthy one, with fallback to the next cheapest if it fails before any output. --- ### DeepSeek V4.1 Flash Abliterated URL: https://inference.dagon.so/models/deepseek-v4.1-flash-abliterated deepseek-v4.1-flash-abliterated is DeepSeek V4.1 Flash Abliterated, an abliterated model with refusal behavior reduced or removed, served by Dagon Inference over an OpenAI compatible API. It costs $0.132 per million input tokens, $0.0275 per million cached input tokens and $0.495 per million output tokens, with a 1,048,576 token context window, up to 65,536 output tokens per request and text input only. 2 providers serve it: Refuseless and Experiential Labs. #### What does DeepSeek V4.1 Flash Abliterated cost? Tokens | Price per 1M | Input | $0.132 | Cached input | $0.0275 | Output | $0.495 | A request with 10,000 input tokens and 1,000 output tokens costs 1,815 µ$, about $0.0018. Prices are Refuseless's, the cheapest provider serving this model, plus the 10% markup (15% on private leases), at price version 2026-11-02.2. A request that falls back to another provider is billed at that provider's rate plus the markup; its signed receipt names the provider. Every model: pricing, models.json, live /v1/models. #### What is it? DeepSeek V4.1 Flash with refusal behavior removed, served by Refuseless. Text only, 1M context. - Model id: deepseek-v4.1-flash-abliterated - Context window: 1,048,576 tokens - Maximum output: 65,536 tokens per request (default cap 16,384) - Input: text input only - Endpoints: /v1/chat/completions, /v1/responses - Providers: Refuseless and Experiential Labs We have not benchmarked it and make no claims about its quality. Individual requests may still be declined or answered poorly. #### How do I call it? Create a key with curl -X POST https://inference.dagon.so/v1/keys or in the console, fund it in USDC, then: ``` curl https://inference.dagon.so/v1/chat/completions \ -H "Authorization: Bearer $DAGON_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "deepseek-v4.1-flash-abliterated", "messages": [{"role": "user", "content": "Hello"}]}' ``` With an OpenAI SDK, set the base URL to https://inference.dagon.so/v1 and the model to deepseek-v4.1-flash-abliterated. The SDK guide has more examples. #### Other models - Abliterated Large v2 (abliterated-model-large-v2): $1.10 input, $2.20 output per 1M tokens - GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated): $0.132 input, $0.55 output per 1M tokens - Abliterated Large Flash (abliterated-model-large-flash): $1.10 input, $2.20 output per 1M tokens - Abliterated Model (abliterated-model): $1.10 input, $3.30 output per 1M tokens **What does DeepSeek V4.1 Flash Abliterated cost per million tokens?** $0.132 per million input tokens, $0.0275 per million cached input tokens and $0.495 per million output tokens (model id deepseek-v4.1-flash-abliterated), including the 10% markup, at price version 2026-11-02.2. **What is the context window of DeepSeek V4.1 Flash Abliterated?** 1,048,576 tokens, with up to 65,536 output tokens per request through Dagon Inference. **Which providers serve deepseek-v4.1-flash-abliterated?** Refuseless and Experiential Labs. Each request goes to the cheapest healthy one, with fallback to the next cheapest if it fails before any output. --- ### GLM-5.3 Flash Abliterated URL: https://inference.dagon.so/models/glm-5.3-flash-abliterated glm-5.3-flash-abliterated is GLM-5.3 Flash Abliterated, an abliterated model with refusal behavior reduced or removed, served by Dagon Inference over an OpenAI compatible API. It costs $0.132 per million input tokens, $0.044 per million cached input tokens and $0.55 per million output tokens, with a 1,048,576 token context window, up to 65,536 output tokens per request and text input only. 2 providers serve it: Refuseless and Experiential Labs. #### What does GLM-5.3 Flash Abliterated cost? Tokens | Price per 1M | Input | $0.132 | Cached input | $0.044 | Output | $0.55 | A request with 10,000 input tokens and 1,000 output tokens costs 1,870 µ$, about $0.0019. Prices are Refuseless's, the cheapest provider serving this model, plus the 10% markup (15% on private leases), at price version 2026-11-02.2. A request that falls back to another provider is billed at that provider's rate plus the markup; its signed receipt names the provider. Every model: pricing, models.json, live /v1/models. #### What is it? GLM-5.3 Flash with refusal behavior removed, served by Refuseless. Text only, 1M context. - Model id: glm-5.3-flash-abliterated - Context window: 1,048,576 tokens - Maximum output: 65,536 tokens per request (default cap 16,384) - Input: text input only - Endpoints: /v1/chat/completions, /v1/responses - Providers: Refuseless and Experiential Labs We have not benchmarked it and make no claims about its quality. Individual requests may still be declined or answered poorly. #### How do I call it? Create a key with curl -X POST https://inference.dagon.so/v1/keys or in the console, fund it in USDC, then: ``` curl https://inference.dagon.so/v1/chat/completions \ -H "Authorization: Bearer $DAGON_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "glm-5.3-flash-abliterated", "messages": [{"role": "user", "content": "Hello"}]}' ``` With an OpenAI SDK, set the base URL to https://inference.dagon.so/v1 and the model to glm-5.3-flash-abliterated. The SDK guide has more examples. #### Other models - Abliterated Large v2 (abliterated-model-large-v2): $1.10 input, $2.20 output per 1M tokens - DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated): $0.132 input, $0.495 output per 1M tokens - Abliterated Large Flash (abliterated-model-large-flash): $1.10 input, $2.20 output per 1M tokens - Abliterated Model (abliterated-model): $1.10 input, $3.30 output per 1M tokens **What does GLM-5.3 Flash Abliterated cost per million tokens?** $0.132 per million input tokens, $0.044 per million cached input tokens and $0.55 per million output tokens (model id glm-5.3-flash-abliterated), including the 10% markup, at price version 2026-11-02.2. **What is the context window of GLM-5.3 Flash Abliterated?** 1,048,576 tokens, with up to 65,536 output tokens per request through Dagon Inference. **Which providers serve glm-5.3-flash-abliterated?** Refuseless and Experiential Labs. Each request goes to the cheapest healthy one, with fallback to the next cheapest if it fails before any output. --- ### Abliterated Large Flash URL: https://inference.dagon.so/models/abliterated-model-large-flash abliterated-model-large-flash is Abliterated Large Flash, an abliterated model with refusal behavior reduced or removed, served by Dagon Inference over an OpenAI compatible API and the Anthropic Messages API. It costs $1.10 per million input tokens, $0.11 per million cached input tokens and $2.20 per million output tokens, with a 1,048,576 token context window, up to 65,536 output tokens per request and text and image input. abliteration.ai serves it. #### What does Abliterated Large Flash cost? Tokens | Price per 1M | Input | $1.10 | Cached input | $0.11 | Output | $2.20 | A request with 10,000 input tokens and 1,000 output tokens costs 13,200 µ$, about $0.0132. Prices are abliteration.ai's, the cheapest provider serving this model, plus the 10% markup (15% on private leases), at price version 2026-11-02.2. A request that falls back to another provider is billed at that provider's rate plus the markup; its signed receipt names the provider. Every model: pricing, models.json, live /v1/models. #### What is it? Fast large model with a 1M context window and image input. - Model id: abliterated-model-large-flash - Context window: 1,048,576 tokens - Maximum output: 65,536 tokens per request (default cap 16,384) - Input: text and image input - Endpoints: /v1/chat/completions, /v1/responses, /v1/messages - Providers: abliteration.ai We have not benchmarked it and make no claims about its quality. Individual requests may still be declined or answered poorly. #### How do I call it? Create a key with curl -X POST https://inference.dagon.so/v1/keys or in the console, fund it in USDC, then: ``` curl https://inference.dagon.so/v1/chat/completions \ -H "Authorization: Bearer $DAGON_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "abliterated-model-large-flash", "messages": [{"role": "user", "content": "Hello"}]}' ``` With an OpenAI SDK, set the base URL to https://inference.dagon.so/v1 and the model to abliterated-model-large-flash. With an Anthropic SDK, use https://inference.dagon.so as the base URL. The SDK guide has more examples. #### Other models - Abliterated Large v2 (abliterated-model-large-v2): $1.10 input, $2.20 output per 1M tokens - DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated): $0.132 input, $0.495 output per 1M tokens - GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated): $0.132 input, $0.55 output per 1M tokens - Abliterated Model (abliterated-model): $1.10 input, $3.30 output per 1M tokens **What does Abliterated Large Flash cost per million tokens?** $1.10 per million input tokens, $0.11 per million cached input tokens and $2.20 per million output tokens (model id abliterated-model-large-flash), including the 10% markup, at price version 2026-11-02.2. **What is the context window of Abliterated Large Flash?** 1,048,576 tokens, with up to 65,536 output tokens per request through Dagon Inference. **Which providers serve abliterated-model-large-flash?** abliteration.ai. Each request goes to the cheapest healthy one, with fallback to the next cheapest if it fails before any output. --- ### Abliterated Model URL: https://inference.dagon.so/models/abliterated-model abliterated-model is Abliterated Model, an abliterated model with refusal behavior reduced or removed, served by Dagon Inference over an OpenAI compatible API and the Anthropic Messages API. It costs $1.10 per million input tokens, $0.11 per million cached input tokens and $3.30 per million output tokens, with a 262,144 token context window, up to 65,536 output tokens per request and text and image input. abliteration.ai serves it. #### What does Abliterated Model cost? Tokens | Price per 1M | Input | $1.10 | Cached input | $0.11 | Output | $3.30 | A request with 10,000 input tokens and 1,000 output tokens costs 14,300 µ$, about $0.0143. Prices are abliteration.ai's, the cheapest provider serving this model, plus the 10% markup (15% on private leases), at price version 2026-11-02.2. A request that falls back to another provider is billed at that provider's rate plus the markup; its signed receipt names the provider. Every model: pricing, models.json, live /v1/models. #### What is it? General model with text and image input. - Model id: abliterated-model - Context window: 262,144 tokens - Maximum output: 65,536 tokens per request (default cap 16,384) - Input: text and image input - Endpoints: /v1/chat/completions, /v1/responses, /v1/messages - Providers: abliteration.ai We have not benchmarked it and make no claims about its quality. Individual requests may still be declined or answered poorly. #### How do I call it? Create a key with curl -X POST https://inference.dagon.so/v1/keys or in the console, fund it in USDC, then: ``` curl https://inference.dagon.so/v1/chat/completions \ -H "Authorization: Bearer $DAGON_KEY" \ -H "Content-Type: application/json" \ -d '{"model": "abliterated-model", "messages": [{"role": "user", "content": "Hello"}]}' ``` With an OpenAI SDK, set the base URL to https://inference.dagon.so/v1 and the model to abliterated-model. With an Anthropic SDK, use https://inference.dagon.so as the base URL. The SDK guide has more examples. #### Other models - Abliterated Large v2 (abliterated-model-large-v2): $1.10 input, $2.20 output per 1M tokens - DeepSeek V4.1 Flash Abliterated (deepseek-v4.1-flash-abliterated): $0.132 input, $0.495 output per 1M tokens - GLM-5.3 Flash Abliterated (glm-5.3-flash-abliterated): $0.132 input, $0.55 output per 1M tokens - Abliterated Large Flash (abliterated-model-large-flash): $1.10 input, $2.20 output per 1M tokens **What does Abliterated Model cost per million tokens?** $1.10 per million input tokens, $0.11 per million cached input tokens and $3.30 per million output tokens (model id abliterated-model), including the 10% markup, at price version 2026-11-02.2. **What is the context window of Abliterated Model?** 262,144 tokens, with up to 65,536 output tokens per request through Dagon Inference. **Which providers serve abliterated-model?** abliteration.ai. Each request goes to the cheapest healthy one, with fallback to the next cheapest if it fails before any output.