# Credits and Billing

Kafkai usage is prepaid. You buy credits, tool calls consume
them, and every response tells you what it cost. There are no
subscriptions and no per-seat fees.

## Buying credits

Credit packs are sold in Japanese yen. Prices are listed on the
[pricing page](https://kafkai.com/en/pricing/), and once you are signed in you buy from
the [top-up page](https://kafkai.com/en/accounts/credits/) — the same packs, one click
from the dashboard. Metered calls need a positive balance, so check
yours before your agent starts work and buy a pack if it is empty.
We sometimes grant free credits to new accounts; when we do, we tell
you how many and how long they last.

Credits are valid for 90 days, counting the day they are added as day
1, and the oldest credits are spent first. The top-up page and the
dashboard show how many credits are still unused from your oldest
purchase and the last day they can be spent, and we email you 14 days
and 7 days before any credits expire. Whatever is unused after the
last valid day is removed, and we email you what was removed and what
is left.

Prices on both pages are quoted with Japanese consumption tax
included, and the smaller line under each pack shows the tax on its
own. Checkout works the tax out from the billing address you enter, so
the total shown there before you pay is the amount charged. A buyer
outside Japan may be charged a different amount.

Every purchase issues a qualified invoice (適格請求書) carrying our
registration number, so a Japanese business can claim the input tax
credit. The payment confirmation links to it.

Credit validity and refund conditions are defined in the
[Terms of Service](https://kafkai.com/en/legal/tos/) — the ToS is the authoritative
document for those rules.

## What a tool call costs

There are two kinds of metered tools. Every price below is the default;
the [pricing page](https://kafkai.com/en/pricing/) carries the amount you are charged.

**Read tools** — everything that returns data you already have — charge
in two parts:

1. a **flat call fee** — 1 credit, the same for every read tool, and
2. a **per-row amount** for the data rows actually returned — 0.1
   credit per row, rounded down.

So a read that returns 100 keywords costs 1 + 10 = 11 credits, and a
read that returns 9 rows or fewer costs 1 credit.

Kafkai checks that your balance covers the call fee before the tool
runs, then deducts both together once the tool has returned data.

Three analysis tools — competitor analysis, ranking changes and SERP
data — carry a higher call fee than a plain list: 2 credits. One more,
`kafkai_find_competitors`, carries its own call fee, because it buys
fresh competitor, authority and judgement data rather than reading
what a project already has; its per-row amount is the same as every
other read, and it counts the competitors returned — the comparison
sites the same call returns are not charged. Nothing else varies. So
a call that returns 20 keywords costs more than one that returns 5,
and asking for a smaller `limit` is the direct way to spend less.

The call fee is charged per call, not per row, so it is worth knowing
which way to page a long list. Reading 100 keywords in one call pays
the call fee once; reading the same 100 20 at a time pays it five
times, for the same rows. When a long list is genuinely needed, ask
for the largest page the tool allows rather than many small ones.

**Research tools** — the ones that make Kafkai go and fetch fresh data —
are priced per site researched, because that is how the work scales:
every site in a run gets its own keyword and backlink research.

- `kafkai_create_project` charges a base fee for your site, plus a
  competitor fee for each competitor you give.
- `kafkai_add_competitor` charges the competitor fee once.
- `kafkai_update_keywords` charges the base fee for your site plus the
  competitor fee for every competitor in the project — the same shape
  as creation, because every site is researched again.
- `kafkai_update_backlinks` charges a smaller backlinks-only fee for
  each site it actually fetches; sites fetched within the last day are
  skipped and not charged.

**The page-one check** — `kafkai_check_search_results` — is priced per
call and per keyword, because it fetches one search result page for
each keyword:

- 1 credit per call, plus
- 5 credits for each keyword Kafkai fetches fresh.

A keyword checked within the last 24 hours is returned from the stored
page and adds nothing. A keyword whose fetch failed adds nothing. There
is no per-row amount.

| Call | Charge |
|---|---|
| 10 keywords, all fetched fresh | 1 + 10 × 5 = 51 credits |
| 3 keywords, all fetched fresh | 1 + 3 × 5 = 16 credits |
| 3 keywords, 1 fetch failed | 1 + 2 × 5 = 11 credits |
| 3 keywords, all checked within the last 24 hours | 1 credit |
| The call is refused, or returns no page at all | 0 credits |

One call takes up to 10 keywords, so one call costs at most 51
credits. Before it fetches anything, Kafkai checks that your balance
covers the highest possible charge for the call.

**The marketplace check** — `kafkai_check_marketplace_results` — has
the same price as the page-one check, for Amazon and for Google
Shopping:

- 1 credit per call, plus
- 5 credits for each new page the call returns.

A keyword checked within the last 24 hours is returned from the stored
page and adds nothing. A page with no listing is an answer and costs
the same as any page. A keyword whose fetch failed adds nothing.
Google Shopping pages arrive about a minute after Kafkai queues them,
so Kafkai charges for them on the call that first returns them.
Queueing is free, but your balance must cover the pages. A call that
only reports keywords still being fetched costs nothing.
`kafkai_set_marketplace_identity` is free.

Each tool states its price in its own description, and the response's
`billing` object shows what a call cost.

These tools are always free:

- `kafkai_get_credit_balance` — checking your balance,
- `kafkai_get_account` — checking which account a connection uses,
- `kafkai_list_projects` — listing your projects,
- `kafkai_get_project_summary` — the overview of one project,
- `kafkai_list_competitors` — listing a project's competitors,
- `kafkai_verify_domain` and `kafkai_check_domain_verification` —
  proving you control a domain,
- `kafkai_update_search_console` — fetching the latest Search Console
  data, once a day per property,
- `kafkai_get_tracking_stack` and `kafkai_update_tracking_stack` —
  reading the tracking setup of your site and competitors,
- `kafkai_delete_project` — deleting a project,
- `kafkai_delete_competitor` — removing a competitor from a project,
- `kafkai_list_publishing_destinations` — listing your publishing
  destinations,
- `kafkai_add_publishing_destination` — adding a publishing
  destination,
- `kafkai_delete_publishing_destination` — deleting a publishing
  destination,
- `kafkai_publish_article` — publishing text your agent wrote to one
  of your destinations.

Kafkai checks before it charges. If your balance cannot cover a
call's fee, the call is refused before it runs. A call that is
rejected — a project that already exists, a competitor that is already
there, an error of any kind — is never charged at all, and nothing
appears on your ledger for it. There are no refunds because there is
never anything to refund.

## What a first project costs

Setting up a project costs the most. Reading its data afterwards is
cheap. This is a typical first session at the default prices:

| Step | Tool | Credits |
|---|---|---:|
| Create a project for your site | `kafkai_create_project` | 500 |
| Find who you compete with (10 sites returned) | `kafkai_find_competitors` | 50 + 1 = 51 |
| Add one competitor | `kafkai_add_competitor` | 350 |
| Read the project overview | `kafkai_get_project_summary` | 0 |
| Read the competitor analysis | `kafkai_get_competitor_analysis` | 2 |
| Read 100 catch-up keywords | `kafkai_get_catchup_keywords` | 1 + 10 = 11 |
| Read 20 compete keywords | `kafkai_get_compete_keywords` | 1 + 2 = 3 |

Setup — the first three steps — costs 901 credits. A read after it
costs 0 to 12 credits. A balance of 1,000 credits leaves 99 after
setup, which pays for 9 reads of 100 keywords, or about 30 reads of 20.

Research data stays in the project. Reading it again costs only the
read price, not the research. Research is charged again only when
you ask for fresh data with `kafkai_update_keywords`,
`kafkai_update_backlinks` or `kafkai_add_competitor`.

## Reading the usage report

Every metered response ends with a `_usage` object:

```json
"_usage": {
  "tool": "kafkai_get_catchup_keywords",
  "rows_returned": 20,
  "base_cost": 1,
  "row_cost": 2,
  "total_cost": 3,
  "balance_remaining": 997
}
```

This is the authoritative record of what a call cost — agents can
report it to you directly, and you can ask at any time:

> How many Kafkai credits do I have left, and what did I spend them
> on?

That question maps to `kafkai_get_credit_balance`, which returns the
balance, lifetime totals, and the last ten transactions with their
per-call breakdowns.

## Watching usage on the web

The [dashboard](https://kafkai.com/en/app/) opens on your current balance, and lists the
last seven days of activity below it — one row per tool call, with the
tool name and cost. The [activity page](https://kafkai.com/en/accounts/activity/) holds
the full ledger, page by page, and lifetime totals live on the
[account page](https://kafkai.com/en/accounts/).

## Running out mid-conversation

When the balance runs dry, tool calls return an error naming the
required amount and your current balance. The agent's conversation
continues; only the Kafkai calls stop. Buy a pack on the
[top-up page](https://kafkai.com/en/accounts/credits/) and the next call goes through —
there is nothing to reconnect.
