> ## Documentation Index
> Fetch the complete documentation index at: https://ai-kb.automationanywhere.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Credits

> Understanding How Credits Are Consumed in EKB

<Warning>
  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](mailto:support@automationanywhere.com), and we will be happy to assist.
</Warning>

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.

<Note>
  **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.
</Note>

## 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](/agents/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

* [A. Chat / Agent Interaction](#a-chat-/-agent-interaction)
  * [Chat Example](#chat-example)
* [B. Knowledge Base](#b-knowledge-base)
  * [Knowledge Base (KB) Ingestion](#knowledge-base-\(kb\)-ingestion)
  * [Document Chunking](#document-chunking)
* [C. Workflow Executions](#c-workflow-executions)
* [D. Smart Tables](#d-smart-tables)

### A. Chat / 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 (KB) 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](#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 (EK uses Gemini 2.5 Flash)                  |
| Platform Chunking       | Free                                                        |
| Chunk Enrichment tokens | \~104 credits (see [Document Chunking](#document-chunking)) |
| **Estimated Total**     | **\~204+ credits**                                          |

<Info>The more optional stages you enable, the higher the per-document ingestion cost. Word-based upload cost is always fixed and predictable.</Info>

#### 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`): input `150 credits` per 1M tokens, output `600 credits` per 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).

<Note>If the same document were uploaded *without Chunk Enrichment* enabled, chunking would consume 0 LLM Token Credits.</Note>

### C. Workflow Executions

| Action             | Credits         |
| :----------------- | :-------------- |
| Workflow execution | 1 per execution |

<Info>The cost is 1 credit per execution, regardless of the number of steps involved.</Info>

### 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](#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

## 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.