Credits
Important notice: To maintain parity with our other Automation Anywhere products, we have increased the UI representation of calculated credits by 10x. Going forward, credits in the UI will be represented in k units (thousands), such as 1k credits for 1,000 credits. This update is currently being rolled out gradually, team by team. Sales, Orders, and Deal Desk teams may have already reached out to support a smoother transition, including assigning additional add-on credits for power users. For questions or discussions, contact support@automationanywhere.com, and we will be happy to assist.
EKB usage is billed in credits, a unified currency that abstracts the underlying costs of running AI-powered workflows. Credits cover two types of activity: flat-rate Platform Action Credits for discrete operations like uploading documents, sending messages, and invoking tools; and variable LLM Token Credits based on how much text is processed and generated by the language model. Together, these two components make up the total cost of any operation in EKB.
This page breaks down how each credit type is calculated, walks through real examples, and explains what factors drive usage up or down.
On-Premise Customers: The credit consumption model on this page describes billing for EKB SaaS/cloud-hosted environments and does not apply to on-premises deployments. On-prem customers run their own instance of EKB and use their own LLM models. Instead, credits are available as an optional governance tool — on-prem super admins can configure and control how many credits are "charged" per activity or task within their org, then assign credit limits to specific teams to measure and cap LLM usage (e.g., to prevent a team from over-consuming LLM resources). Once a team exhausts its assigned credits, members will be unable to perform further agentic tasks until the limit is increased or reset.
Core Concepts
What Are Credits?
Credits are the unit of measurement EKB uses to track and bill for platform usage. Rather than billing separately for every underlying resource (compute, API calls, LLM usage), credits provide a single, unified currency that abstracts those costs into a predictable format.
Credits are consumed in two ways:
- Platform Action Credits are flat-rate charges tied to specific user actions — uploading a document, sending a chat message, or invoking a tool. These are fixed and predictable regardless of content size or model used.
- LLM Token Credits are variable charges based on actual language model usage. Because LLM costs depend on how much text goes in and comes out of the model, these credits fluctuate based on document size, response length, and model selection.
Your total credit consumption for any operation is always the sum of both types.
What Are Tokens?
Tokens are the unit that Large Language Models use to process text. Before any text is read or generated by an LLM, it is broken down into tokens — small fragments that roughly correspond to words or parts of words.
As a general rule of thumb:
- 1 token ≈ 4 characters, or roughly ¾ of a word in English
- A 100,000-word document is approximately 133,000 tokens
- A short sentence like "Explain this document" is around 4–5 tokens
LLM providers charge separately for input tokens (the text sent to the model — your prompt, retrieved document chunks, system instructions) and output tokens (the text the model generates in response). Input and output rates differ, and both contribute to your LLM Token Credit consumption. For per-model input and output credit rates, see Predefined and Custom Models.
In EKB, token usage grows when large documents are retrieved into context, many knowledge base chunks are included in a prompt, or the model produces long or structured responses.
Credit Consumption Table
Jump to: Chat / Agent · Knowledge Base · Workflows · Smart Tables
Rates in the examples below are illustrative. Input/output credit rates change by model and over time — see Predefined and Custom Models for current pricing.
A. Chat and Agent Interaction
Fixed platform credits
| Action | Credits |
|---|---|
| User sends a chat message | 1 credit |
| Tool call invoked | 1 per call |
Variable LLM Token Credits
LLM credits are calculated as:
(Input Tokens × Input Rate) + (Output Tokens × Output Rate)
Example pricing (Claude 4.5 sample model):
-
Input: 3,000 credits ($3) per 1M tokens
-
Output: 15,000 ($15) credits per 1M tokens
Chat Example
Scenario
User asks: "Explain the attached document."
Platform credits
| Component | Credits |
|---|---|
| Question asked (1 chat message) | 1 |
| 1 Tool call (document retrieval) | 1 |
| Subtotal | 2 |
LLM token usage (model: Claude 4.5 sample — 3,000 credits per 1M input tokens, 15,000 credits per 1M output tokens)
| Type | Tokens | Credits |
|---|---|---|
| Input | ~53,634 | ~161 |
| Output | ~900 | ~13.5 |
| Total | — | ~175 |
Final total
| Component | Credits |
|---|---|
| Fixed platform | 2 |
| LLM usage | 175 |
| Total | 177 |
B. Knowledge Base
Knowledge Base credit consumption spans two stages: ingesting documents into a Knowledge Base, and the optional document chunking and enrichment step that prepares content for retrieval.
Knowledge Base Ingestion
Uploading a document to a Knowledge Base triggers a multi-stage ingestion pipeline. Each stage has its own cost structure, and some stages incur additional LLM Token Credits depending on your project configuration.
Ingestion Pipeline
| Stage | Description | Cost |
|---|---|---|
| 1. Document Upload | File is received and word count is calculated | 10 credits per 10,000 words |
| 2. LLM Extraction (optional) | An LLM parses and extracts content from the document | Input + output tokens × model rate |
| 3. Platform Chunking | Tokenization, splitting, and metadata assembly | Free (platform) |
| 4. Chunk Enrichment (optional) | An LLM generates a context prefix for each chunk | Input + output tokens × model rate |
Stages 2 and 4 are only billed when enabled in your Project Settings. Document chunking occurs as part of ingestion and may incur additional costs. See Document Chunking for a detailed breakdown.
Example – 10,000 word document (no optional stages enabled)
| Item | Credits |
|---|---|
| 10,000 words | 10 credits |
Example – 100,000 word document (no optional stages enabled)
| Item | Credits |
|---|---|
| 100,000 words | 100 credits |
Example – 100,000 word document (all stages enabled)
| Item | Credits |
|---|---|
| 100,000 words (upload) | 100 credits |
| LLM Extraction tokens | Varies by model (EKB uses Gemini 2.5 Flash) |
| Platform Chunking | Free |
| Chunk Enrichment tokens | ~104 credits (see Document Chunking) |
| Estimated Total | ~204+ credits |
Document Chunking
Chunking is the step between document extraction and embedding. It takes the cleaned text from an uploaded document and breaks it into smaller pieces (chunks) that are indexed in the vector store and later retrieved for Chat or Agent queries.
Chunking costs fall into two categories:
- Platform Chunking: Deterministic operations (tokenization, splitting, metadata assembly) that run locally on the server and are not billed as LLM usage.
- Chunk Enrichment (LLM Token Credits): Billed only when Chunk Enrichment is enabled for the project in Knowledge Base Settings. The LLM generates a short context prefix for each chunk; both input and output tokens are charged.
Example: Document Chunking Costs
The following example assumes a moderately sized document with Chunk Enrichment enabled:
- Document size: 100,000 words (~133,000 input tokens, at 4 chars/token)
- Chunk settings:
chunk_size=64 tokens,chunk_overlap=10 tokens→ ~2,300 chunks - Chunk Enrichment: Enabled with
gpt-4o-mini - Output text (joined chunks incl. enrichment prefixes): ~140,000 output tokens
- Model pricing (example,
gpt-4o-mini): input150 creditsper 1M tokens, output600 creditsper 1M tokens
| Component | Tokens | Credits |
|---|---|---|
| Input Tokens (document) | 133,000 | ~19.95 |
| Output Tokens (chunks) | 140,000 | 84 |
| Total LLM Credits | 273,000 | ~104 |
This document's Chunk Enrichment consumes approximately 104 credits (~19.95 input + 84 output).
C. Workflow Executions
| Action | Credits |
|---|---|
| Workflow execution | 1 per execution |
D. Smart Tables
Smart Tables combine LLM-powered extraction with agent-driven workflows. Credit consumption depends on which computation path is used.
| Action | Credits |
|---|---|
| LLM computation | Charged based on input and output tokens; cost depends on the selected LLM. |
| Agent computation | Charged the same way as a Chat / Agent Interaction |
What Drives LLM Credit Usage?
LLM cost increases when:
▶ Higher-cost models are used
▶ Large documents are retrieved into context
▶ Many KB chunks are injected into the prompt
▶ Responses are long
▶ Multiple tool calls are triggered
Team and project credit ceilings
Beyond how credits are calculated, team admins can set governance ceilings on the shared pool:
| Ceiling | Where |
|---|---|
| Sub-team credit cap (team + descendants) | Sub-teams |
| Project credit allocation | Project Billing |
| Subtree usage dashboard | Credit Consumption |
These ceilings do not create separate wallets — they limit how much of the shared team pool a branch or project may use in a billing period.
Important Notes for Customers
✓ Word-based ingestion cost is predictable.
✓ Chat costs vary significantly depending on document size and the number of tokens used.
✓ Model pricing is configurable in Super Admin.
✓ LLM credits are consumption-based and cannot be flat-rated.
✓ Final credit total = Platform Credits + LLM Credits.