n8n AI Agent Cost: On Small Models, the Fee Is 10x Tokens

An n8n AI agent has two bills. n8n charges one execution for each production run, which for a chatbot is each message a user sends: on Cloud Starter that’s $20 a month (billed annually) for 2,500 runs, or $0.008 a run. The model’s tokens are billed on top. At an assumed 6,000 input and 500 output tokens per turn, a turn costs about $0.00085 on Claude Haiku 5.5 or GPT-6 Luna and about $0.017 on Claude Sonnet 5.5 or GPT-6.1 Sol. That’s $0.85 vs $17 per 1,000 turns (C$1.19 vs C$23.86; A$1.21 vs A$24.10).

Run your own numbers in the n8n vs Make vs Zapier cost calculator.

The token counts are a modelled assumption, not a measurement. Measure 20 real runs of your own agent before you budget (the checklist below shows how). Prices checked 29 Oct 2026 on n8n.io, app.n8n.cloud, Anthropic’s and OpenAI’s pricing pages. CAD at the Bank of Canada rate of 1.4036 (28 Oct 2026) and AUD at the RBA rate of 0.7053 USD per AUD (29 Oct 2026). Prices exclude any sales tax, GST or HST.

How much does an n8n AI agent cost per run?

The execution share. Divide the plan price by its execution allowance (n8n pricing, US view, 29 Oct 2026):

That share only holds if you use the whole allowance. An agent that handles 300 messages a month on Starter really costs $20 ÷ 300 = about $0.067 a run.

What counts as an execution for an AI agent

n8n’s docs define an execution as “a single run of a workflow” and say only production executions count toward your quota: runs started by triggers, schedules or polling (n8n docs). Specifically:

• Webhook triggers count one execution for every inbound request that activates them, including empty-body requests.
• Manual test runs in the editor don’t count.
• Sub-workflows called with Execute Sub-workflow don’t count separately; only the parent does.
• Error workflows don’t count.

For a chat agent, that means one execution per user message that reaches a published workflow, because each message starts a new run (that’s our reading of how chat triggers work: confirm it in your own execution list). Ten back-and-forth messages in one conversation are ten executions. The agent’s internal loop (call model, call tool, call model again) happens inside that one execution.

n8n AI credits explained: Gateway vs Assistant vs your own key

The “n8n AI credits” confusion comes from there being two credit types plus the option to skip both.

Sources: Gateway credits and Assistant credits docs. The size of each plan’s Assistant allowance is on the pricing page; we haven’t listed it here because it isn’t what runs your agent.

When to use Gateway credits: you want one bill and no provider accounts, or you’re prototyping. When to use your own key: you’re on Enterprise or self-hosted (Gateway isn’t available), you want provider-side features like batch discounts, or you need a data agreement directly with the provider. n8n’s docs note that with Gateway credits the provider sees your request content but not your identity, because calls go through n8n’s own provider account.

Which models you can use with Gateway credits, and what they cost

All prices per 1 million tokens, input / output, checked 29 Oct 2026:

Sources: n8n service pricing, Anthropic pricing, OpenAI pricing. Anthropic also notes that Claude 4.7 and later models use a tokenizer that produces “approximately 30% more tokens for the same text” than earlier models, so token counts from an older model’s logs will undercount.

Cost per 1,000 agent runs by model (USD, CAD, AUD)

Assumption: 6,000 input and 500 output tokens per turn, one model call per turn, no caching. Token cost only:

Now add n8n. On Starter billed annually, 1,000 runs use $8 worth of the plan if you fill it:

That’s the main takeaway: on a small model, the n8n plan is your real cost, and moving to self-hosted n8n saves far more than switching models. On a frontier model, tokens dominate and model choice matters most.

Why agent runs cost more than one AI step

An AI Agent node isn’t one model call. When the agent decides to use a tool, the typical loop is:

1. Call the model with the system prompt, memory, tool definitions and the user message.
2. The model asks for a tool; n8n runs it.
3. Call the model again with everything from step 1 plus the tool result.

So a turn with one tool call sends the input context twice. At our assumption, that roughly doubles input tokens: about $0.00145 instead of $0.00085 on Haiku 5.5, still one n8n execution. Tool definitions add tokens to every call too; Anthropic lists a tool-use system prompt of 286 tokens on Claude 5.5 models with tool choice auto.

If your workflow just needs one prompt in and one answer out (classify a lead, summarize an email), a Basic LLM Chain is cheaper than an agent. Our n8n lead generation workflow uses that cheaper pattern.

Free n8n AI agent template (importable JSON)

A minimal support agent: Chat Trigger → AI Agent with Simple Memory (last 5 exchanges), an Anthropic chat model, and one HTTP Request tool that looks up order status. Max iterations is set to 4 so a confused agent can’t loop and burn tokens.

{
  "name": "Support agent (unboxth starter)",
  "nodes": [
    {
      "parameters": { "public": true, "options": {} },
      "name": "When chat message received",
      "type": "@n8n/n8n-nodes-langchain.chatTrigger",
      "typeVersion": 1.1,
      "position": [0, 0]
    },
    {
      "parameters": {
        "options": {
          "systemMessage": "You are a support agent for Example Co. Answer in under 80 words. Use the order_status tool only when the user gives an order number. If unsure, say you will hand off to a human.",
          "maxIterations": 4
        }
      },
      "name": "AI Agent",
      "type": "@n8n/n8n-nodes-langchain.agent",
      "typeVersion": 1.7,
      "position": [260, 0]
    },
    {
      "parameters": { "model": "claude-haiku-5-5", "options": { "maxTokensToSample": 400 } },
      "name": "Anthropic Chat Model",
      "type": "@n8n/n8n-nodes-langchain.lmChatAnthropic",
      "typeVersion": 1.3,
      "position": [180, 220]
    },
    {
      "parameters": { "contextWindowLength": 5 },
      "name": "Simple Memory",
      "type": "@n8n/n8n-nodes-langchain.memoryBufferWindow",
      "typeVersion": 1.3,
      "position": [320, 220]
    },
    {
      "parameters": {
        "toolDescription": "order_status: look up the shipping status of an order. Input: the order number.",
        "url": "https://api.example.com/orders/{{ $fromAI('order_number') }}",
        "options": {}
      },
      "name": "order_status",
      "type": "n8n-nodes-base.httpRequestTool",
      "typeVersion": 4.2,
      "position": [460, 220]
    }
  ],
  "connections": {
    "When chat message received": { "main": [[{ "node": "AI Agent", "type": "main", "index": 0 }]] },
    "Anthropic Chat Model": { "ai_languageModel": [[{ "node": "AI Agent", "type": "ai_languageModel", "index": 0 }]] },
    "Simple Memory": { "ai_memory": [[{ "node": "AI Agent", "type": "ai_memory", "index": 0 }]] },
    "order_status": { "ai_tool": [[{ "node": "AI Agent", "type": "ai_tool", "index": 0 }]] }
  }
}

To use it: in n8n, create a new workflow, paste the JSON onto the canvas, then open the Anthropic node and pick either Gateway credits or your own Anthropic credential. Replace the example URL with your real order API. Node typeVersion numbers change between n8n releases; if a node shows a warning after import, open it and let n8n update it. We built this as a starting point and haven’t tested it on every n8n version.

How to cap AI agent costs in n8n

• Set max iterations. It limits how many model-tool loops one turn can take.
• Keep memory short. A 5-exchange window instead of 20 cuts input tokens on every turn.
• Route with a small model. Use Haiku 5.5 or GPT-6 Luna to classify the request, and only send hard cases to Sonnet or Sol.
• Cap output. A max-tokens setting stops long rambles; output tokens cost 5x input on most models above.
• Use prompt caching where your provider supports it. Anthropic prices cache hits at 0.1x input on Haiku 5.5 and 0.05x on Sonnet and Opus 5.5. Whether n8n’s nodes send cache headers depends on the node and version; check your provider’s usage logs.
• Watch Gateway spend. The Gateway credits page in the Cloud console shows spend over time, and top-ups can be manual or automatic.

Measure your own cost (20-run checklist):

• Publish the workflow and send 20 realistic messages.
• For each execution, note input and output tokens from the model node’s output (or your provider’s usage log).
• Average them, then multiply by your model’s rates above.
• Count executions per conversation from the executions list.
• Add your plan’s execution share at your real monthly volume, not the full allowance.

When the n8n plan, not the tokens, is the bigger bill

Using the tables above:

• Under about 2,500 messages a month on a small model: Starter’s $20 (C$28.07, A$28.36) is nearly the whole bill. Tokens are under $3.
• 2,500 to 10,000 messages: Pro at $50 (C$70.18, A$70.89) annual. Tokens on Haiku would be $2 to $9.
• Beyond 10,000 messages: Pro’s 50,000 tier at $120 annual or $144 monthly, or self-host. See n8n self-hosted vs cloud cost.
• Any volume on Sonnet/Sol or Opus: tokens overtake the plan quickly. 10,000 turns on Sonnet 5.5 is about $170 in tokens versus $50 for Pro.

If you’re still choosing a platform, n8n vs Make vs Zapier pricing compares how each bills multi-step workflows, and Zapier alternatives covers the wider field. For AI coding tool prices, see Claude Code vs Codex vs Cursor pricing. More guides live in the AI automation hub.

To price your own token counts across Claude, GPT and Gemini, use the free LLM API Cost Calculator.