Liquid Inference docs

The docs render in the browser. Each page is also a Markdown file. /llms.txt lists every page, and /llms-full.txt has all pages in one file.

Guides

• Overview: Buy inference, connect your tools, or sell your own models.
• Quickstart: Make an API key and send your first request. Then read what it cost.
• Liquid CLI: Install the CLI and sign in. Then start your coding agent on the exchange.
• API keys: Make, limit and revoke API keys. Set scopes, spending limits and expiry.
• Purchasing rules: Choose the models, the ranking and the limits for each request.
• Bring your own key: Connect your own cloud key. The exchange then sends requests through your account.
• Preferred providers: Try providers in order, then use the rest of the eligible market.
• Receipts: Read the receipt of a job and check the charge.
• Fees: The exchange fee: the percentage, the token floor, free offers and discounts.
• Workloads in the API: Send the profile of a saved workload, and what it does and does not do.
• Price and wait: How the exchange adds the value of the wait to the charge, and how to change it.
• How performance is measured: The base latency, prefill and output speed that the exchange measures.
• Axis routing: Rank offers by smartest, fastest or cheapest with a model-name suffix.
• Market data: Read the public book of offers, market depth and the live feed.
• Reservations: Buy a monthly pool of tokens from one provider at a fixed fee, through a preset.
• Auto Router: Let liquid.auto choose the model by published score and charge, within a cap.
• Modalities: The map: what you can send, what you can buy, the formats, and what each costs.
• Image input: Send an image to a chat model.
• Audio input: Send an audio clip to a chat model.
• Document input: Send a PDF to a chat model.
• Speech-to-text: Buy a transcript of an audio file with an unchanged OpenAI client.
• Image generation: Buy images with an unchanged OpenAI client.
• Speech: Buy spoken audio from text.
• Video generation: Create a video, poll its status and download it.
• Reference inputs: Start an image, speech or video job from images, audio or video.
• Embeddings: Buy vectors for text with an unchanged OpenAI client.
• Structured output: Ask for a JSON answer, check it against a schema, and try a format in the playground.
• Prompt caching: Cache the start of a long prompt. A read costs less than input; a write can cost more.
• Response caching: Store a whole answer and get it back at no charge.
• Workloads: Find the cheapest model that does your repeat task right, then ship it.
• Request fixes: Let the playground suggest one change after a failed request.
• Regional availability: The locations that cannot use Liquid Inference.
• Data handling: What the exchange stores, where text is held for a short time, and who can see it.
• Guardrails: Limit providers, spend and the text of calls for a whole workspace.
• Workspace members: Owner, admin and member roles, and how to add or remove a person.
• Organizations: Pay for several workspaces from one balance, with one budget.
• Audit log: See who issued a key, changed a member or changed a guardrail, and when.
• Provider claims: What the badges on a provider mean, and how to require a claim.
• Notifications: See low balance, key limit and payment notices in the bell.
• Referrals: Earn credit on the fees from the people you refer.
• OpenRouter: Change the base URL and key, and move the provider object to exchange.
• LiteLLM: Point the SDK or the proxy at the exchange, and move fallbacks and retries.
• OpenAI API: Change the base URL and key, and check which OpenAI features carry over.
• Anthropic API: Change the base URL and key, and remove the tools that run on a server.
• Portkey: Replace a Portkey config with an exchange object or a preset.
• What changed: New controls, the older names that still work, and two changes in behavior.
• Sora API: Keep the /v1/videos code. Change the base URL, the key and the model, and set a cap.

Tutorials

• All tutorials: Pick a tutorial by what you want to do. Each one goes from a clean start to a working result.
• Run a coding agent on a budget: Start Claude Code on the exchange with a key that cannot spend more than you set.
• Create and showcase a project: Record your coding sessions, publish a project page and share what you built.
• Make a storyboard with Claude Code: Use Liquid MCP and Claude Code to write a script and draw each frame.
• Build semantic search: Embed your notes through the exchange and search them by meaning.
• Transcribe a meeting and summarize it: Turn an audio file into text, then into a short summary with action items.
• Sell your first model: Register as a provider, quote one model and see your first award.

Integrations

• All integrations: Find the guide for your coding agent, SDK or app.
• Connect an app: Base URLs, keys and which guide to use for your tool.
• Claude Code: Point Anthropic's terminal agent at the exchange.
• Codex: Add the exchange as a provider for OpenAI's terminal agent.
• GitHub Copilot CLI: Point the Copilot CLI at the exchange with environment variables.
• Grok Build: Add the exchange as a custom model for xAI's Grok Build agent.
• Pi: Add the exchange as a provider for the Pi coding agent.
• Factory Droid: Add the exchange as a custom model for the Factory Droid coding agent.
• Oh My Pi: Use a separate profile with native model discovery and a cap for each request.
• Reason: Add the exchange as a Custom provider for the hosted Reason agent.
• Crush: Add the exchange as a provider in your crushrc with a separate buyer key and request cap.
• Goose: Use a shared custom provider file with a separate buyer key and request cap.
• Hermes Agent: Set the model block with a separate buyer key and a cap for each request.
• OpenClaw: Install the Liquid Inference plugin, with a cap for each request.
• OpenCode: Add the exchange as a provider for OpenCode.
• Paperclip: Set the OpenCode adapter provider for a Paperclip agent.
• Cursor: Override the OpenAI base URL in the editor.
• DeepSeek Harness: Point the DeepSeek agent harness at the exchange.
• Z Code: Add a custom provider in the Z.ai desktop agent.
• Cline: Use the OpenAI-compatible provider in the VS Code agent.
• Roo Code: Use the OpenAI Compatible provider in the VS Code agent.
• Kilo Code: Use the OpenAI Compatible provider in the VS Code agent.
• RikkaHub: Add a custom provider in the Android chat app.
• Open WebUI: Add the exchange as a connection in the self-hosted chat front end.
• Cherry Studio: Add an OpenAI-compatible provider in the desktop chat client.
• n8n: Send text, image and video requests with the HTTP Request node or the OpenAI node.
• Dify: Add the exchange as a model provider in the LLM app platform.
• LobeHub: Set the OpenAI provider proxy URL for a team of agents in LobeHub.
• ComfyUI: Buy images and videos in a workflow, with a cap on each run.
• OpenAI SDK: Call Chat Completions or Responses directly from Python or TypeScript.
• Anthropic SDK: Call the Messages API directly from Python or TypeScript.
• Claude Agent SDK: Run Claude Code and its tools as a library, with a cap on each request.
• OpenAI Agents SDK: Run an agent loop and local tools through Responses, with a cap on each request.
• Vercel AI SDK: Run model calls and local tools through Chat Completions, with a cap on each request.
• LiteLLM: Call the exchange through the OpenAI-compatible route of the Python library.
• LangChain: Use the OpenAI chat and embedding classes with the exchange as their base URL.
• OpenHands: Use the Python SDK or the terminal CLI with local tools and a cap for each request.
• LlamaIndex: Embed documents with the OpenAI-like embedding class and the exchange as its base URL.
• pgvector: Buy vectors from the exchange and store and search them in Postgres.
• Qdrant: Buy vectors from the exchange and store and search them in a collection.
• Pinecone: Buy vectors from the exchange and store and search them in an index.
• RAGFlow: Buy chat answers and embeddings for a document search engine.
• Liquid MCP server: Give an agent tools to list models, read the book and buy an answer.
• MCP servers: Use any model on the exchange with the tools of an MCP server.

Plugins

• DeepSeek Harness: Add a Liquid model route and market tools to DeepSeek Harness.
• Hermes Agent: Add the exchange to Hermes Agent as a model provider.
• Dify: Add the exchange to Dify as a model provider.
• ComfyUI: Buy images and videos in a ComfyUI workflow.
• Apps: Plugins, nodes and guides for the exchange, each with its own repository.
• Liquid Inference guide: Guides, reference providers and skills in one open-source repository.
• Skills: Agent skills that teach a coding agent to use the exchange.

API reference

• API overview: Base URLs, authentication and a map of every endpoint.
• Errors: Find an error by code or status, and see what to change.
• Chat Completions: Buy one completion in the OpenAI format.
• Responses: The same auction in the OpenAI Responses format.
• Messages: The same auction in the Anthropic format, and a token count.
• Decisions: Typed questions with a probability for each option, in the Jev format.
• Embeddings: Vectors for text, in the order of the texts.
• Images: Generate images.
• Transcriptions: Transcribe an audio file.
• Speech: Generate spoken audio.
• Video: Create a video, poll its status and download it.
• Models: The names that you can use as the model of a request.
• Market data: The public book, market depth, routers and the live feed.

Sell

• Become a provider: Start here to sell. Apply, get admitted and make a provider key.
• Deployments: Register the models that you sell. List, pause and price them.
• Quote over the session: Send your prices to the exchange over the provider session.
• Quote a media model: Declare controls and sizes, and write the price table for images, speech and video.
• OpenAI-compatible API: No agent: the exchange calls your API directly.
• Anthropic API: No agent: the exchange calls your Messages API.
• Run your agent: Set up the agent, choose the route for each kind of job, upgrade, and use the handover capability.
• Images: The route your upstream needs, the answer, and the price.
• Speech: The route your upstream needs, the audio answer, and the price.
• Transcription: The multipart route, the verbose answer, and the price.
• Video: The routes your upstream needs, the registration and the checks before you quote.
• Serve and get paid: With an agent: dispatch requests, response events, settlement and payouts.
• Provider API: The catalogue calls and the provider session.
• Bring your own key: Connect a cloud key, register its models and sell them with no serving stack.
• Reservations: Quote a monthly token pool, link a committed deployment, and get the fee each month.