Pricing
Building your AI agent will always be free.
Credits fund the compute that is required to run your agent.
Running an AI agent requires enormous computational power to process client inputs, analyze data, and generate intelligent responses in real time. Every action your agent takes—from understanding complex natural language to executing multi-step workflows—consumes backend server resources like GPUs and high-performance memory.
Because these computing infrastructure costs scale directly with the resource demands of your AI agent, credits ensure you only pay for the exact amount of processing power your agent actually utilizes.
What an API Call Costs
An API call is a request to your agent — it's how a message gets sent to your agent, and how your agent's response gets back to your app. Each API call consumes credits. The amount of credits consumed depends on how much work your agent does.
Five things drive the price of any given API call:
- How much your agent has to read: The client's message, the messages up to that point,
and anything you pass in
extra_context. Long sessions cost more than short ones, because the agent re-reads the entire history each time to stay in context. - How much it writes back: Longer responses cost more than short ones.
- How hard the request is: Requests that take real reasoning to work through cost more than ones your agent can answer straight away.
- Whether it searches the web: Your agent decides on its own when a question needs live information, and each web search it runs adds to the cost of that API call.
- How long your agent runs: Agents consume computing resources while active, as a result, longer tasks cost more than those finished in seconds.
Run time is billed, and it is not the same as the other four.
Two identical prompts can take different amounts of time, because your agent decides for itself how much work a request needs — how many steps to take, how many searches to run, how much to think through before it answers.
The first four drivers above are still what moves it. A request that reads less, searches less and answers shorter also finishes sooner, so the savings in Keeping Your Costs Down below cut your run time along with everything else.
The amount of credits consumed per API call changes based on the assigned task.
An agent fielding questions that need live information will search often and spend far quicker than one answering from your own data. Anyone's "average consumed credits" is a number about their agent, not yours.
Your free trial credits are there to answer this properly. Run your agent on realistic traffic for a few days and read your actual numbers off the Monitor page.
When You're Charged
The rule in one line: you pay when your agent runs, and only then.
| What happened | Charged? |
|---|---|
| Your agent answered the request | Yes |
| Your agent ran, but rejected the request as invalid | Yes — the work still happened |
| You cancelled the request while your agent was running | Yes — see below |
| Something went wrong on our side | No |
| You went over your rate limit | No |
| Your API key was missing or invalid | No |
| Your request was malformed and never reached your agent | No |
| You were out of credits | No |
The second row is the one worth reading twice. If a request gets far enough for your agent to pick it up and act on it, that API call is billed even when the outcome is not what you wanted — your agent ran, and that compute was consumed either way. Requests that fail before reaching your agent never consume anything, so they are free.
If we fail to deliver a response, that's on us and you are not charged.
Cancelled requests
Cancelling a request stops you waiting for the answer. It does not stop your agent, which keeps running to completion and finishes the work — including writing what it found to its memory, where a later request can read it back. So a cancelled request is charged, at what it actually cost, exactly as though you had waited for it.
Running Low
An API call needs a balance above zero to start.
When yours runs out, the API response comes back like this:
402 Payment Required
Top up on the Credits page and your API calls resume immediately.
A small negative balance is normal
The cost of an API call is not known until it finishes, so an API call that starts with a nearly-empty balance can end with it slightly below zero. That is expected — we would rather complete a request you have already sent than cut your agent off mid-response.
Your next purchase clears it automatically. Nothing else is affected.
To avoid running out at all, turn on auto-refill from the Credits page. Pick a balance to trigger at and a pack to buy, and we will top you up in the background before your balance runs out.
Keeping Your Costs Down
Most of what drives cost is under your control:
- Start a new session when the topic changes: Sending
reset_session: "yes"on your Response-Agent API call clears the history the agent re-reads. Letting one session run for hundreds of messages makes every API call in it progressively more expensive. This is usually the easiest saving available. - Pass only the
extra_contextyour agent needs: It is read on every API call it is included in, so trim anything the agent does not actually need. - Keep your instructions tight: The purpose, instructions, and guardrails defined within your Agent Build are read on every single API call. Clear, concise rules cost less than sprawling ones — and as Tips for Building covers, they work better too.
- Ask for what you need: If your use case suits short answers, say so in your rules. An agent told to be concise writes less and costs less.
Tracking What You Spend
The Monitor page shows credits spent per day over the last 30 days, alongside your request counts and error rates — so you can see what a normal day costs you and spot a change in shape early. It also carries your all-time totals.
Your current balance, your packs, and your auto-refill settings all live on the Credits page.