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

# KIME API use cases

The KIME API exposes the same data and actions available through the MCP tools, callable directly from your own backend, scripts, or product — no AI assistant required. Use it whenever you want something to run unattended: on a schedule, inside a CI/CD pipeline, embedded in your own product's UI, or synced with another system. See your authentication guide for base URL and credential details — this page assumes you can already make an authenticated call and focuses on what to build with it.

<Note>
  This guide describes what each category of endpoint enables and the shape of data it returns. Response fields shown in examples are illustrative — your own data, competitors, and citations will reflect your workspace.
</Note>

## Why the API instead of the dashboard or MCP

The dashboard is for a person looking something up. MCP is for a person asking a question through an assistant. The API is for a system that needs to act without anyone in the loop — running on its own schedule, reacting to events, or living inside a product other people use. Reach for it when:

* Something needs to happen on a recurring schedule (a nightly report, a weekly digest) with no manual step.
* You're building a feature into your own product that surfaces KIME data to your own users or customers.
* You want to react automatically to a change (a sentiment drop, a new competitor ad) rather than someone noticing it.
* You're integrating with another system (a PM tool, a CRM, a data warehouse, a CMS) where the sync itself should be code, not a conversation.

## Dashboards and white-label reporting

Pull visibility, share-of-voice, sentiment, and a composite performance score into your own UI instead of sending people to log into KIME directly.

A performance-style endpoint returns one composite scorecard, well suited to a KPI tile:

```json theme={null}
{
  "performance_score": 0,
  "visibility_score": 0,
  "position_score": 0,
  "sentiment_score": 0
}
```

A visibility-style endpoint returns a time series, one series per tracked brand, ready to feed a line chart:

```json theme={null}
{
  "chart_data": [
    { "date": "<date>", "<competitor-id>": 0, "<your-brand-id>": 0 }
  ],
  "brands": [
    { "id": "<id>", "name": "<name>", "brandType": "competitor" },
    { "id": "<id>", "name": "<name>", "brandType": "core" }
  ]
}
```

This is the foundation for two distinct patterns: an **internal dashboard** for your own team, or a **white-label / multi-tenant portal** — an agency managing many client workspaces can build one internal tool that loops through workspaces and renders each client's own branded view, with no per-client KIME login required and full control over look and feel. The same data can also be embedded as a widget inside your own product if you want to surface AI-visibility metrics to your own customers as a feature.

## Scheduled reporting and digests

The same read endpoints, called on a schedule (a cron job or a scheduled function) instead of on page load, formatted into whatever channel your team actually reads: a Slack or Teams message, an email digest, a generated PDF, or a row appended to a spreadsheet.

A recurring job can pull performance scores across every tracked workspace or brand, rank them, and post a summary to an internal channel on a fixed cadence — fully unattended, with no one needing to remember to check a dashboard.

## Threshold-based alerting

Poll the analytics endpoints on a schedule, diff against the previous period, and trigger a notification when something crosses a threshold you define. Useful signals to alert on include:

* A meaningful period-over-period sentiment score change
* A competitor's share-of-voice overtaking yours on a tracked query set
* Sponsored ads beginning to appear in your category's AI answers where they weren't before, via the ads-share endpoints

A growth or brand team gets notified the moment something worth reacting to happens, instead of discovering it days later during a routine check-in.

## Two-way sync with your project management tool

The Actions Center backlog is fully readable and writable via the API, not just for display purposes. Each task carries a task type (content creation, content update, "get mentioned in this article," "pitch for exclusive content," "add a trust signal," and others), a priority, a status that moves through a defined lifecycle (suggested, to-do, in progress, in review, done or rejected), and a full brief — source URLs with citation counts, which of your tracked prompts it would help win, and either a content brief or extracted outreach contact details (name, email, phone) for mention/PR-type tasks.

<Note>
  The full task lifecycle is scriptable end to end: create a task, comment on it, fetch it individually or in bulk by ID, and update its status — the same operations your dashboard performs are available as direct calls.
</Note>

A sync job can poll for newly suggested tasks, create a matching ticket in whatever PM tool your team already uses with the brief pre-filled, and mirror status and comments back in both directions as either system changes — so your team's existing workflow tool stays the single source of truth, with KIME feeding it structured, pre-prioritized work instead of being a separate silo someone has to remember to check.

## Automated content pipeline: gap to draft to publish

Chain the Actions Center to the content generator to your actual publishing target. A completed content-generation job's export includes full SEO metadata (title, slug, meta description, primary and secondary keywords), Open Graph and social card data, a ready-to-use structured-data block (including a populated FAQ schema where relevant), and the complete article body — available in multiple formats, including a WordPress-compatible import format alongside plain JSON, Markdown, and HTML.

A pipeline can watch for an approved content task, poll until the linked generation job completes, pull the export in whichever format your CMS accepts, and import it automatically — going from "here's a content gap" to "here's a published or ready-to-publish page" with no manual writing step and no manual export/import click. Gate the final publish step behind a human approval if you want a review checkpoint without giving up the rest of the automation.

## Bulk prompt and tracking provisioning

Create up to several hundred prompts in a single call, each tagged with the right location and category.

<Warning>
  Each prompt created this way triggers real model runs across every AI engine enabled in the workspace — a genuine write and spend action, not a dry run. Gate large batches behind a review step rather than running this as a fully silent background job.
</Warning>

This is the backbone of two common operational patterns: an **agency onboarding flow** that generates a templated prompt set (branded, non-branded, and comparison queries) programmatically from a client's product and competitor list and submits it in one call instead of a team member typing dozens of prompts into a UI by hand; and a **new-market or new-product launch checklist** that provisions tracking automatically as part of a broader launch automation, polling for completion before the first report is due.

## AI-crawler monitoring in CI/CD

A website-health-style endpoint runs a real crawl and scores `robots.txt` and structural accessibility individually for major AI crawlers (OpenAI's, Anthropic's, Perplexity's, and others) — not a single pass/fail, but a per-bot, per-category breakdown.

Wire this into a deploy pipeline, or a scheduled job that runs independently of deploys, so a change that accidentally blocks an AI crawler fails the build or opens a ticket automatically — the AI-search equivalent of a broken-link checker, and something a classic SEO crawler doesn't check at all. Because the response includes category-level scores and per-page detail, it can also feed a "GEO readiness" tile alongside existing performance and accessibility metrics in an internal engineering dashboard.

## Blending AI-visibility data into your own data warehouse

Pull the analytics endpoints into your data warehouse (Snowflake, BigQuery, Redshift, or similar) on a schedule and join against your own CRM, product, or revenue data.

This answers questions no single tool can answer alone — for example, whether a rise in AI share-of-voice for a given product line correlates with pipeline or signups some weeks later — by putting AI-visibility metrics next to the rest of the company's data instead of leaving them in a separate silo only accessible through a dashboard.

## Outreach and PR CRM sync

Mention and exclusive-content-pitch tasks come back with the citing page's author name, email, phone, or contact-page URL already extracted as structured data, not something you have to look up manually.

Feed these directly into an outreach tool or CRM as ready-made contact records, so a PR or partnerships team's pipeline starts with "here's who to contact and why it matters" instead of a manual research step for every opportunity.

## Multi-workspace and portfolio orchestration

Every operation above is scoped to a single workspace, but nothing stops you from looping across many. Agencies, holding companies, and platforms managing several brands can build a thin orchestration layer that enumerates workspaces, runs the same pull or sync logic against each, and aggregates the results — a single script maintaining dozens of client integrations instead of one-off manual setups per client.

## Embedding KIME data as a feature in your own product

If you're building a product that already serves a marketing, SEO, or brand-management audience, the same read endpoints can back a native "AI visibility" feature inside your own application rather than sending users to a separate tool — your product handles the UI and your own auth, and calls out to the API server-side to populate it.

## Notes for building on the API

* **Pagination:** list endpoints return `items` (or a similarly named results field), `totalCount`, `limit`, and `offset` — page by incrementing `offset` by `limit` until it reaches `totalCount`. Defaults and maximums vary by endpoint.
* **Large payloads:** citation analysis, the advertiser directory (which can include embedded image data for creative previews), and the AI website health check (full per-page crawl detail) can return large responses on an active, heavily-tracked workspace — request narrow date ranges, use available filters, and handle pagination in code rather than assuming a single response is complete.
* **Sentiment scale:** a 0–100 scale, where a score above the midpoint is positive, below it is negative, and exactly at the midpoint is neutral.
* **Engine filtering:** most analytics endpoints accept a filter for a specific AI engine or search surface, letting you build an engine-by-engine breakdown instead of only a blended number — useful if your audience or strategy differs meaningfully by platform.
* **Location format:** prompt locations use standard two-letter country codes (or a recognized country name normalized to one) — broad regions aren't accepted as a location value.
* **Idempotency and retries:** for anything that writes (creating prompts, creating or updating tasks), design your automation to handle retries safely — check current state before re-submitting rather than assuming a failed-looking response means nothing happened.

<Warning>
  Write endpoints are real. Bulk prompt creation triggers billable model runs, and Actions Center writes go directly to the same backlog your team sees in the dashboard — test any destructive or costly automation against a disposable or sandbox workspace first.
</Warning>

## Capability index

| Capability                                                           | Access       | What it's for                                               |
| -------------------------------------------------------------------- | ------------ | ----------------------------------------------------------- |
| Workspace / brand / category / tag discovery                         | read         | Resolve IDs to scope every other call                       |
| Prompt list, detail, bulk-create, run-status                         | read + write | Manage the query set you're tracked on                      |
| Visibility, share-of-voice, performance                              | read         | Core competitive KPIs                                       |
| Sentiment, sentiment breakdown, brand insights, topic keywords       | read         | AI perception, at both summary and excerpt level            |
| Citation analysis, source domains                                    | read         | Which pages AI cites, and how they sentiment-score          |
| AI website health                                                    | read         | Per-bot crawler and technical accessibility audit           |
| Ads share (plus by category/location), advertisers, creatives        | read         | Sponsored-ad intelligence inside AI answers                 |
| Actions Center tasks (list, get, bulk-get, create, update, comments) | read + write | The GEO gap-to-execution backlog                            |
| Content task list and export                                         | read         | Publish-ready generated content (JSON, Markdown, HTML, WXR) |

## When to reach for MCP instead

If a person needs to ask a question in natural language, get a diagnosis rather than a raw number, or review something before it happens, that's a better fit for the MCP tools through an AI assistant. See **KIME MCP — Use Cases** for that side of the picture; both surfaces expose the same underlying data and actions.