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

# Credits and rate limits

> The two meters, what every call costs, and how fast you can call.

export const CostTable = ({groups}) => <table>
    <thead>
      <tr>
        <th>Call</th>
        <th>MCP tool</th>
        <th>API credits</th>
        <th>Notes</th>
      </tr>
    </thead>
    <tbody>
      {groups.flatMap(group => [<tr key={group.group}>
          <td colSpan={4}><strong>{group.group}</strong></td>
        </tr>, ...group.items.map(item => <tr key={group.group + item.call}>
            <td>{item.call}</td>
            <td>{item.tool ? <code>{item.tool}</code> : ""}</td>
            <td>{item.credits}</td>
            <td>{item.note || ""}</td>
          </tr>)])}
    </tbody>
  </table>;

export const costs = [{
  group: "Account",
  items: [{
    call: "Get account",
    tool: "get_account",
    credits: 0,
    note: "Always free."
  }]
}, {
  group: "Projects, topics and prompts",
  items: [{
    call: "List projects",
    tool: "list_projects",
    credits: 1
  }, {
    call: "Get project",
    tool: "get_project",
    credits: 1
  }, {
    call: "List topics",
    tool: "list_topics",
    credits: 1
  }, {
    call: "List prompts",
    tool: "list_prompts",
    credits: 1,
    note: "Per call of up to 25 rows."
  }, {
    call: "Add topic",
    tool: "add_topic",
    credits: 1
  }, {
    call: "Add prompts",
    tool: "add_prompts",
    credits: 1,
    note: "Per call, up to 50 prompts."
  }, {
    call: "Run a prompt now",
    tool: "run_prompt_now",
    credits: 1,
    note: "Plus 1 realtime credit."
  }]
}, {
  group: "Answers and what we found in them",
  items: [{
    call: "Get visibility",
    tool: "get_visibility",
    credits: 1
  }, {
    call: "List responses",
    tool: "list_responses",
    credits: 1,
    note: "Per call of up to 25 rows. 2 with the answer text."
  }, {
    call: "Get response",
    tool: "get_response",
    credits: 2
  }, {
    call: "List sources",
    tool: "list_sources",
    credits: 1,
    note: "Per call of up to 25 rows."
  }, {
    call: "Top source domains",
    tool: "top_source_domains",
    credits: 2
  }, {
    call: "Get share of voice",
    tool: "get_competitors",
    credits: 2
  }, {
    call: "List rankings",
    tool: "list_rankings",
    credits: 1,
    note: "Per call of up to 25 rows."
  }, {
    call: "List query fanout",
    tool: "get_query_fanout",
    credits: 1,
    note: "Per call of up to 25 rows."
  }, {
    call: "Web search",
    tool: "get_web_search",
    credits: 2,
    note: ""
  }, {
    call: "Get sentiment",
    tool: "get_sentiment",
    credits: 1
  }]
}, {
  group: "Exports",
  items: [{
    call: "Estimate an export",
    tool: "estimate_export",
    credits: 0,
    note: "Always free."
  }, {
    call: "Create export",
    tool: "create_export",
    credits: 0,
    note: "Spends Export rows instead, one per row."
  }, {
    call: "List exports",
    tool: "list_exports",
    credits: 1
  }, {
    call: "Get export",
    tool: "get_export",
    credits: 0,
    note: "Always free. Poll this."
  }, {
    call: "Download export",
    tool: null,
    credits: 0,
    note: "Always free."
  }]
}, {
  group: "Content",
  items: [{
    call: "Create article",
    tool: "create_content_article",
    credits: 1,
    note: "Plus 1 AI content credit."
  }, {
    call: "Get article run",
    tool: "get_content_run",
    credits: 0,
    note: "Free. 2 with the article text."
  }, {
    call: "Retry article run",
    tool: "retry_content_run",
    credits: 1
  }]
}];

export const PlanTable = ({rows}) => <table>
    <thead>
      <tr>
        <th>Plan</th>
        <th>API credits per month</th>
        <th>Export rows per month</th>
        <th>Rows per card export</th>
        <th>Requests per minute</th>
        <th>Requests per second</th>
      </tr>
    </thead>
    <tbody>
      {rows.map(plan => <tr key={plan.name}>
          <td>{plan.name}</td>
          <td>{plan.apiCredits.toLocaleString("en-US")}</td>
          <td>{plan.exportRows.toLocaleString("en-US")}</td>
          <td>{plan.cardExportRows.toLocaleString("en-US")}</td>
          <td>{plan.perMinute.toLocaleString("en-US")}</td>
          <td>{plan.perSecond.toLocaleString("en-US")}</td>
        </tr>)}
    </tbody>
  </table>;

export const plans = [{
  name: "Trial",
  apiCredits: 50,
  exportRows: 1000,
  cardExportRows: 5000,
  perMinute: 30,
  perSecond: 5
}, {
  name: "Lite",
  apiCredits: 250,
  exportRows: 30000,
  cardExportRows: 5000,
  perMinute: 30,
  perSecond: 5
}, {
  name: "Growth",
  apiCredits: 750,
  exportRows: 250000,
  cardExportRows: 15000,
  perMinute: 60,
  perSecond: 10
}, {
  name: "Pro",
  apiCredits: 1500,
  exportRows: 600000,
  cardExportRows: 30000,
  perMinute: 120,
  perSecond: 10
}];

export const limits = {
  ipPerMinute: 600,
  heavyPerMinute: 10,
  writePerMinute: 20,
  promptsPerDay: 200,
  promptsPerCall: 50,
  rowsPerPage: 25,
  mcpRowsPerCall: 25,
  mcpAnswerChars: 1500,
  mcpAnswerCharsMax: 6000,
  maxDaysRows: 31,
  maxDaysVisibility: 366,
  cardExportRows: 5000,
  exportMaxDays: 365,
  exportMaxRows: 250000,
  exportFileDays: 7,
  downloadLinkMinutes: 30,
  exportsPerUser: 1,
  exportsPerOwner: 3
};

## The two meters

| Meter       | What it counts                                      | Spent by                                                                     |
| ----------- | --------------------------------------------------- | ---------------------------------------------------------------------------- |
| API credits | Calls. Most cost 1, heavier ones cost 2.            | Every REST request and every MCP tool call.                                  |
| Export rows | Rows. An export costs exactly the rows it contains. | Creating an export, and the Export buttons on dashboard cards. Nothing else. |

Both belong to the project owner. Both are shown in [Settings, API usage](https://radarkit.ai/settings/api/usage). `GET /me` returns both balances and is free.

The Export buttons on dashboard cards spend Export rows too, one per row in the file. Before anything is charged you see the row count and confirm. The file downloads at once, and a copy is kept for {limits.exportFileDays} days under Project Settings, Export data, where everyone on the project can download it. A card file stops at a number of rows set by your plan (the "Rows per card export" column below); only the rows written are charged. For more rows, use Export data.

## What each call costs

<CostTable groups={costs} />

Row endpoints return up to 25 rows per call and a `next_cursor`; each call is one credit, so 350 responses is 14 calls. Running a prompt now also spends 1 realtime credit. Writing an article also spends 1 AI content credit. The API credit is only for the call itself.

## Every response tells you

```json theme={"system"}
"credits": { "charged": 1, "remaining": 2948 }
```

The same numbers are in the headers `X-RadarKit-Credits-Charged` and `X-RadarKit-Credits-Remaining`.

## Failed calls cost nothing

A call is charged before it runs and refunded if it fails on our side. Validation and permission errors are refused before anything is charged. With no API credits left, every metered call gets `402 INSUFFICIENT_CREDITS`. With no Export rows left, creating an export gets `402 INSUFFICIENT_EXPORT_ROWS`.

## Plan allowances and speed

The plan bucket refills on every renewal. Top-up credits do not expire and are used after the plan bucket is empty. Both rate limit windows must have room.

<PlanTable rows={plans} />

Enterprise plans have custom allowances and rate limits. [Contact us](https://radarkit.ai/contact) for yours.

Need more? Write to [mail@radarkit.ai](mailto:mail@radarkit.ai).

## Extra limits

| Calls                                                                        | Limit per key                                                      |
| ---------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| Heavy reads: top source domains, share of voice, sentiment, export estimates | {limits.heavyPerMinute} per minute                                 |
| Creating an export, running a prompt now, creating an article                | {limits.heavyPerMinute} per minute                                 |
| Adding topics or prompts, retrying an article                                | {limits.writePerMinute} per minute                                 |
| Prompts added                                                                | {limits.promptsPerDay} per rolling 24 hours, REST and MCP together |
| Any single IP address                                                        | {limits.ipPerMinute} per minute, whatever keys it uses             |

## When you hit a limit

You get `429 RATE_LIMITED` and a `Retry-After` header with the seconds to wait. Nothing was charged.

```json theme={"system"}
{
  "error": {
    "code": "RATE_LIMITED",
    "message": "Too many requests. Slow down and retry.",
    "details": { "retry_after": 21 }
  },
  "request_id": "req_01j9x4r2s3t4u5v6w7x8y9z0a1"
}
```

Every response carries `X-RateLimit-Limit` and `X-RateLimit-Remaining` for the per-second window.

<Tip>
  Ask for the largest page you need, up to {limits.rowsPerPage} rows. Use the summary endpoints before the row endpoints. For more than a few thousand rows, create an export: one call, one file.
</Tip>