hashference.com

# Hashference

> Turn your compute into inference. Hashference serves open models and Claude through one OpenAI- and Anthropic-compatible API. A workspace's API keys share one balance, funded by mining (point a CPU, GPU or ASIC at Hashference), by paying with QUAI, Qi, USDT on Ethereum, USDC on Ethereum, USDC on Base, BTC or XMR, or by staking QUAI. No email or KYC required. Agents without a key can also pay for a single request with x402 work: a few seconds of their own machine's computation. Hashference is the first service on the x402 Work marketplace (https://x402.qu.ai).

## Get an API key

Pick whichever fits; every route gives the same kind of hf_ key.
- On your own, no person involved: sign in with a Quai wallet you control. POST https://hashference.com/v1/auth/wallet/challenge {"address":"0x00…"} with the header `Origin: https://hashference.com`; sign the returned message with that address (EIP-191 personal_sign, e.g. quais `wallet.signMessage(address, message)`); POST https://hashference.com/v1/auth/wallet {"nonce","signature"} with the same Origin to get a session token; then POST https://hashference.com/v1/profile/api-keys {"label":"my agent"} with `Authorization: Bearer <session token>`. The key is in apiKey.apiKey. The address must be a Cyprus-1 Quai address (starts 0x00). Guide: https://hashference.com/docs/agents.md.
- For a person's workspace (device login): POST https://hashference.com/v1/device/code, show user_code and open verification_uri_complete for the person to approve, then poll POST https://hashference.com/v1/device/token every `interval` seconds until it returns the key. The CLI does this: `hashference login`.
- A person can also create keys at https://hashference.com/keys.
- No key at all: pay per request with x402 work (below).

## Featured hosted models

- Qwen3.8 27B, provider **Dominant Inference**. Model ID: `hashference-qwen3.8-27b`. Served through Hashference at https://hashference.com/v1/chat/completions, including streaming and client-run function tools. Use your normal Hashference API key; no direct provider URL or provider key is needed.
- Price per million tokens: $0.0018 input, $0.0225 output, 99% below the equivalent hosted checkpoint. Live prices and cached-input rates: https://hashference.com/v1/catalog. The provider is featured first in the catalog.
- Limits: 98304 input tokens (estimated from request size at two bytes of request JSON per token, so about 192 KB) and 8192 maximum output tokens per request. Workspace keys share rate and concurrency limits; 429 includes Retry-After. Credit balances and per-key monthly budgets also apply.
- DeepSeek V4.1 Flash, provider **Dominant Inference**. Model ID: `hashference-deepseek-v4.1-flash`. Served through Hashference at https://hashference.com/v1/chat/completions, including streaming; function tools are not enabled on this endpoint. Use your normal Hashference API key; no direct provider URL or provider key is needed. This qualified endpoint uses greedy sampling only: temperature is 0, sampling modifiers are normalized, and responses carry x-hashference-sampling.
- Price per million tokens: $0.027 input, $0.3 output, 79% below the equivalent hosted checkpoint. Live prices and cached-input rates: https://hashference.com/v1/catalog. The provider is featured first in the catalog.
- Limits: 98304 input tokens (estimated from request size at two bytes of request JSON per token, so about 192 KB) and 8192 maximum output tokens per request. Workspace keys share rate and concurrency limits; 429 includes Retry-After. Credit balances and per-key monthly budgets also apply.

## Call a model with an API key

- Hosted catalog: Venice **Private** text models; anonymous, TEE and E2EE Venice routes are excluded. Claude is also served through **OpenRouter**, restricted to Anthropic and zero-retention endpoints (data_collection: deny, zdr: true). Each model names its provider; a provider catalog outage leaves the other available. Query /v1/models for current IDs; unavailable models are not silently replaced by different checkpoints. Dominant Inference keeps its own IDs and prices.
- Venice models support Chat Completions, stateless Responses (Venice beta), and Anthropic Messages via text/function translation. Messages accepts the base ID or its -messages twin. No native Claude model is implied by Anthropic compatibility.
- Send full conversation history on every request. Stored response IDs and previous_response_id are unavailable. Responses text.format is rejected; use Chat Completions response_format for structured output. Venice Messages accepts and ignores output_config.effort and reasoning_effort. System-role conversation messages are supported; private Claude thinking blocks are omitted when resuming on an open model. Extended thinking, other output_config fields, media and server-run tools remain unsupported. Native Claude Messages routes support their own Anthropic fields within the published text/function limits. Streaming, text, function tools and usage are supported; check supports_tools per model.
- OpenAI SDKs and Chat Completions or Responses clients: base URL https://hashference.com/v1. Anthropic SDKs and Claude Code: base URL https://hashference.com (the origin; they add /v1/messages).
- Authenticate with `Authorization: Bearer <key>`, or `x-api-key: <key>`. Keys start with hf_.
- Endpoints: POST https://hashference.com/v1/chat/completions, POST https://hashference.com/v1/responses, POST https://hashference.com/v1/messages (and /v1/messages/count_tokens). stream:true returns server-sent events; tools and tool_choice work on Chat Completions.
- Model metadata: context_length is the shared input/output window; max_input_tokens is an optional additional input ceiling; max_output_tokens is the effective route cap (at most 100,000); default_max_output_tokens is used when omitted. supports_tools is route-specific; tool_choice_modes, when listed, restricts tool selection. Some Claude ZDR routes support auto/none but cannot force a named function or require a call; unsupported choices return 400 before billing. Reserve output space inside context_length; any separate max_input_tokens budget uses the route’s documented input estimate.
- Models: GET https://hashference.com/v1/models (send anthropic-version for Anthropic's list shape), or GET https://hashference.com/v1/catalog for each model's protocol, availability and price per million tokens. /v1/messages also accepts Anthropic's own Claude IDs when those models are served.
- Your balance and history: GET https://hashference.com/v1/account. Usage by model: GET https://hashference.com/v1/usage?days=1|7|30|90.

## Connect a coding agent or app

- Claude Code in one line: `ANTHROPIC_BASE_URL="https://hashference.com" ANTHROPIC_AUTH_TOKEN="hf_..." ANTHROPIC_API_KEY="" ANTHROPIC_MODEL="deepseek-v4-flash-messages" ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-v4-flash-messages" CLAUDE_CODE_SUBAGENT_MODEL="deepseek-v4-flash-messages" MAX_THINKING_TOKENS=0 claude`. Any OpenAI-compatible app: set OPENAI_BASE_URL=https://hashference.com/v1 and OPENAI_API_KEY to the key.
- Set up any of these as a fallback for when a Claude, ChatGPT or other subscription hits its limit, as the main provider, or for cheaper subagents: https://hashference.com/skill.md (an Agent Skill covering keys, funding, mining, model choice and settings for Hermes, Claude Code, Codex, OpenCode and OpenClaw).
- Exact settings for Claude Code, Cursor, VS Code (Claude Code extension or Cline), Codex, OpenCode, Cline, Roo Code, Kilo Code, Hermes Agent and OpenClaw: https://hashference.com/docs/connect.md.
- MCP: https://hashference.com/mcp (Streamable HTTP, JSON responses). Clients with MCP OAuth (Claude, ChatGPT, Cursor, VS Code, Claude Code) need only the URL: the person signs in and approves, and the client gets its own key. Others send a Bearer API key: `claude mcp add --transport http hashference https://hashference.com/mcp --header "Authorization: Bearer hf_..."`. Tools: list_models, get_balance, chat, get_funding_options, create_funding_invoice, check_invoice, get_deposit_address, list_deposits, get_mining_setup. Locally, `hashference mcp` has the same tools plus x402_chat, which pays with the agent's own machine.
- CLI: `npm i -g https://hashference.com/hashference-0.1.4.tgz`, then `hashference login` (approve in the browser), `hashference setup <tool>`, `hashference status`, `hashference x402 ask "…"`, `hashference fund --usd 10` (QUAI invoice), `hashference fund --coin USDC --network base` (deposit address), `hashference deposits`, `hashference mine`.

## Fund a workspace

- Start with GET https://hashference.com/v1/funding: it lists every option this deployment has switched on for your key.
- QUAI or Qi by invoice ($1 to $500): POST https://hashference.com/v1/payments {"asset":"QUAI","creditMicrousd":10000000}, or for Qi {"asset":"QI","creditMicrousd":10000000,"payerPaymentCode":"<the sending wallet's public Qi payment code>"}. The invoice gives the exact amount, receiving address (or Qi payment code) and expiresAt (about 5 minutes). Send exactly that amount on Quai Mainnet before it expires, then poll GET https://hashference.com/v1/payments/{id} (awaiting_payment → confirming → paid, or review). If you paid by hand, POST https://hashference.com/v1/payments/{id}/verify {"transaction":"0x…"}. Send optional requestId to make retries safe.
- Other coins (USDT and USDC on Ethereum, USDC on Base, BTC, XMR, where enabled): GET https://hashference.com/v1/funding lists what this deployment accepts, this key's addresses, and deposit events (pending confirmations, credited, below-minimum or review). POST https://hashference.com/v1/deposit-addresses {"coin":"USDC","network":"base"} returns this key's own address for that coin, reused for every later top-up. Any amount from $1 is credited at the value received once the network confirms it (stablecoins at $1; BTC and XMR at the market price then). After broadcasting an Ethereum/Base token payment, POST https://hashference.com/v1/deposits/track {"coin":"USDT","network":"ethereum","transaction":"0x…"} to retain its pending status even across a reload. This does not issue credit. GET https://hashference.com/v1/deposits shows each deposit from the moment it is submitted or the network sees it: pending (stage submitted or mempool), confirming (confirmations/requiredConfirmations), crediting, credited, below_minimum, needs_review, failed or expired. Pending funds are not spendable. If amountKnown is false, the displayed amount is not yet known to the node; track a replacement hash if the wallet replaces the transaction. People can do the same under Buy credits at https://hashference.com/account?buy=1.
- Mining: CPUs, GPUs and ASICs. Live routes:
  - SHA-256d (Quai) on SHA-256 ASIC: stratum+tcp://mine.hashference.com:4333 — e.g. `miner --url stratum+tcp://mine.hashference.com:4333 --user <username>.worker-01 --pass x`
  - Scrypt (Quai) on Scrypt ASIC: stratum+tcp://mine.hashference.com:4334 — e.g. `miner --url stratum+tcp://mine.hashference.com:4334 --user <username>.worker-01 --pass x`
  - KAWPOW (Quai) on GPU: stratum+tcp://mine.hashference.com:4338 — e.g. `miner --url stratum+tcp://mine.hashference.com:4338 --user <username>.worker-01 --pass x`
  - RandomX (Monero) on CPU or GPU: stratum+tcp://mine.hashference.com:4337 — e.g. `xmrig -o mine.hashference.com:4337 -u <username>.worker-01 -p x`
  Miners log in as <username>.<worker-name> with password x, where <username> is account.miningUsername from GET https://hashference.com/v1/account (the MCP tool get_mining_setup and `hashference mine` print a ready command); each share the pool accepts becomes credit at once, in the workspace balance every key spends. Mining credit is recorded against the workspace's first key, which is the one with earnsMiningCredit true; false on other keys does not mean their workspace misses out. GET https://hashference.com/v1/mining/routes has live status and exact settings. Setup: https://hashference.com/docs/mining.md.
- 1,000 credits are $1. A 402 from inference says how much the request needs (error.required_credits, available_credits, shortfall_credits) and lists API links in error.funding: options, plus invoice, deposit_address, mining and x402 where this deployment has them.

## Pay per request with work (no key, no account)

- POST https://hashference.com/x402/v1/chat/completions, /x402/v1/responses or /x402/v1/messages with the normal request body. The first call returns 402 with a work puzzle priced for that request (model price × prompt and output limit); solve it and retry the same body with PAYMENT-SIGNATURE. Discovery, profiles and whether it's funded: GET https://hashference.com/v1/x402.
- Profiles live here: monero/randomx-v1, quai/sha256d-v1. GET https://hashference.com/v1/x402 has the current list and prices.
- Use x402-work-client 0.4.1 or newer for the current mining-value RandomX offers. In Node: `npm install https://x402.qu.ai/x402-work-client-0.4.1.tgz`, then `import { payWithWork } from 'x402-work-client'` and `await payWithWork(url, body, { maxPrice })`. From a shell: `npx --package=https://x402.qu.ai/x402-work-client-0.4.1.tgz x402-work …`. Or `hashference x402 ask "…"`.
- RandomX is offered on Monero first. Hashference CLI 0.1.1 and x402-work-client CLI 0.4.1 find a solver on PATH or download and verify the matching Linux/macOS (Intel or Apple Silicon) binary. Existing explicit paths still work: X402_WORK_RANDOMX_SOLVER=/path/to/x402-work-randomx. In code, import ensureRandomxSolver from x402-work-client/solver and pass randomx: async () => ({ solver: await ensureRandomxSolver() }); setup happens only for an affordable selected RandomX offer. The CLI accepts --randomx-solver /path/to/x402-work-randomx. The client accepts up to 150,000 RandomX guesses by default and selects fast mode when at least 3 GiB is available to its process, including container limits. Set X402_WORK_RANDOMX_FAST=0/1 to choose light/fast mode. At mining-value prices a CPU needs RandomX and usually the hosted default model; it cannot solve the SHA-256d offers in time. Other platforms can provide a solver built from source. Price errors list each offered algorithm and its own limit; a missing RandomX solver is identified explicitly.
- Discovery includes defaultModel, defaultEndpoint and defaultMaxTokens; use that endpoint and model for a small first request. Each proof is single-use: request a challenge and randomize extraNonce2 for every payment. If PAYMENT-RESPONSE says success, the proof is spent even if inference returns an error. Never replay it or reset the solver to the same solution. A provider rate limit returns 429 with Retry-After; during its cooldown a 503 requests no new work. Choose another model or wait.
- The exchange, challenge fields, solution encoding and troubleshooting: https://x402.qu.ai/docs/pay.md (all x402 Work guides in one file: https://x402.qu.ai/llms-full.txt). Hashference specifics: https://hashference.com/docs/x402.md.

## Rules

- Read https://hashference.com/v1/capabilities and https://hashference.com/v1/catalog for live availability, protocols and prices. Use returned model IDs; never assume an example model or an optional feature is live.
- All API keys in a workspace spend one shared balance. A key can have a monthly budget.
- Each request reserves credit, then settles at actual usage, rounded up to a whole micro-dollar (0.001 credit, also the minimum). GET /v1/usage has each request's exact charge (costMicrousd); replies report tokens, not cost. A max_tokens above a model's output limit is lowered to the limit (header x-hashference-max-tokens-clamped). Explicit prompt-cache markers (cache_control) are removed, so requests run uncached at the published rate. reasoning_effort is passed to the provider as its reasoning setting.
- Text in, text out: image, audio and file inputs are rejected with 400.
- Work-paid requests never add credit to a balance, and work never refunds after it settles.
- Credits come from a paid QUAI or Qi invoice, a confirmed deposit to one of your own deposit addresses, mining, or a staking plan. QUAI and Qi always go through invoices where invoices are enabled; every other coin goes to a deposit address. Coins sent anywhere else add nothing.
- Staking plans: stake exactly 100,000 QUAI (Starter, $20 of credit a month) or 1,000,000 QUAI (Pro, $200 a month) in the staking contract from a linked Pelagus wallet. Credit is added at the start of each 30-day period while the stake renews and expires when the period ends; unstaking unlocks the full principal at the end of the current period. https://hashference.com/v1/staking shows the terms and whether it's live; send nothing until it is. Guide: https://hashference.com/docs/staking.md.
- Keep API keys on your backend, never in browser code.

## Machine interfaces

- [OpenAPI](https://hashference.com/openapi.json): every endpoint in this file, with request and response schemas.
- [Capabilities](https://hashference.com/v1/capabilities): live feature status and discovery links.
- [Models](https://hashference.com/v1/models) and [catalog with prices](https://hashference.com/v1/catalog)
- [Mining routes](https://hashference.com/v1/mining/routes): Stratum endpoints and availability.
- [x402 work](https://hashference.com/v1/x402): work profiles, prices and funding for per-request payment.
- [MCP](https://hashference.com/mcp): remote MCP server; OAuth sign-in or a Bearer API key. [Agent Skill](https://hashference.com/.well-known/skills/hashference/SKILL.md).
- [Statistics](https://hashference.com/v1/stats): public aggregates of tokens, models, apps, devices, mining shares and x402 payments.
- [Full documentation](https://hashference.com/llms-full.txt): every guide below in one file.
- [CLI](https://hashference.com/docs/cli.md): `npm i -g https://hashference.com/hashference-0.1.4.tgz`.

## Guides

- [Introduction](https://hashference.com/docs/introduction.md): Hashference is an OpenAI-compatible API for open models. Fund it with crypto or stablecoins, with mining work, or pay per request with x402 work. No email or KYC required.
- [Quickstart](https://hashference.com/docs/quickstart.md): Create a workspace, make an API key, and send your first request with the SDK you already use.
- [Connect your tool](https://hashference.com/docs/connect.md): Exact settings for the coding agents and apps people use with Hashference. Replace hf_... with your API key, and <model-id> with any ID from GET /v1/models.
- [Authentication](https://hashference.com/docs/authentication.md): API keys authorize inference. Sessions authorize the console. Keep both off the client.
- [Agents and automation](https://hashference.com/docs/agents.md): Everything an agent needs to use Hashference on its own: get a key (with no person involved if it has a Quai wallet), find models, pay for them, and check what happened.
- [Chat Completions](https://hashference.com/docs/chat-completions.md): OpenAI-compatible chat. Works with the OpenAI SDKs and most tools that speak Chat Completions.
- [Responses](https://hashference.com/docs/responses.md): The OpenAI Responses API, with the same keys and balance as every other endpoint.
- [Anthropic Messages](https://hashference.com/docs/messages.md): Anthropic-compatible Messages for tools and SDKs built on the Anthropic API. Venice Private models use a text and function-tool adapter; this does not turn them into Claude. Select a current Messages model from the catalog. Claude Code effort hints are accepted and ignored, system-role conversation messages are supported, and private Claude thinking blocks are omitted from resumed history. Extended thinking, structured output_config, images and server-run tools remain unsupported.
- [Models and catalog](https://hashference.com/docs/models.md): Discover which models a deployment serves, which API each one speaks, and what it costs.
- [Errors and limits](https://hashference.com/docs/errors-limits.md): What each status code means, and the limits every client should plan for.
- [Credits and billing](https://hashference.com/docs/credits.md): Every request reserves credit first, then settles at actual usage. All API keys in a workspace spend one shared balance.
- [Pay with crypto](https://hashference.com/docs/quai-payments.md): Buy inference credits with QUAI, Qi or another coin. QUAI and Qi get an exact, time-limited quote; other coins go to your workspace’s own deposit address.
- [Mining for credits](https://hashference.com/docs/mining.md): Point a CPU, GPU or ASIC at Hashference. Accepted work becomes credit on your account.
- [Pay per request](https://hashference.com/docs/x402.md): Proof of work per request: an agent with no key or balance pays for one call with a few seconds of its own machine’s work, using x402 Work. The work pays for that call only; it mines nothing for you and never becomes credit.
- [Stake QUAI](https://hashference.com/docs/staking.md): Stake 100,000 QUAI for $20 of inference a month, or 1,000,000 QUAI for $200 a month. Your QUAI stays in the staking contract.
- [CLI](https://hashference.com/docs/cli.md): Sign in from your terminal, set up your coding tools, run an MCP server for your agent, pay with x402 work, and add credits.