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

# Cencori

> Bring Cencori model spend into CostGraph, pulled by CostGraph or pushed by Cencori

Cencori is AI infrastructure that meters every model call your projects make and
bills it at its own price. One connection captures that spend across every
project, model, and upstream model maker in your Cencori organization.

CostGraph reads Cencori as **FOCUS 1.2** records at a grain of day x project x
model x endpoint x sub-account. Each record is priced at what Cencori billed you.

## What lands in CostGraph

* Model spend per day, for each Cencori project and model.
* Optionally, spend per end user or per tenant, so you can charge model cost back
  to your own customers.
* Request counts and token counts, split into input, cache read, cache write, and
  output tokens.
* The model maker behind each call, such as Anthropic or OpenAI, and the kind of
  work it did, such as text generation, embeddings, or image generation.

## Choose how the data reaches us

<CardGroup cols={2}>
  <Card title="CostGraph pulls it" icon="cloud-arrow-down">
    You supply a read-only usage export key and we call Cencori once a day. Nothing to run.
  </Card>

  <Card title="Cencori pushes it" icon="cloud-arrow-up">
    You connect CostGraph from the Cencori console and Cencori sends us the same records.
  </Card>
</CardGroup>

<Warning>
  Use one or the other for a Cencori organization, not both. Connecting it both
  ways counts the same spend twice.
</Warning>

## Before you begin

* In Cencori, open **Organization settings > Advanced > Usage export** and create a
  key. Organization owners and admins can create one. Cencori shows the key once,
  so copy it before you close the dialog. It starts with `cuk_`.
* Copy your Cencori organization id from **Organization settings > General >
  System identifier**. CostGraph uses it as the billing account.

A usage export key is read-only and covers every project in the organization. A
project secret key also works, but it sees only its own project and can spend
money if it leaks. Use a usage export key.

## Let CostGraph pull

1. Open **Settings > Integrations** and pick **Cencori**.
2. Name the connection and pick the tenant these charges belong to.
3. Paste the usage export key and the Cencori organization id.
4. Optionally, choose what spend is attributed to:
   * `project` attributes spend to each Cencori project. This is the default.
   * `end_user` attributes spend to the end-user id your application sends on
     each request.
   * `tenant` attributes spend to the tenants of your embedded agents.
   * `none` leaves the sub-account empty.
5. Select **Connect**.

CostGraph verifies the credentials with a short fetch before saving, so a wrong
value or a missing permission fails while you are still on the form.

CostGraph reads each day after it has closed in UTC, so today's spend appears the
following day.

<Note>
  Credentials are encrypted at rest and used only to read billing data. Revoke the
  key in Cencori at any time and the connection stops. Nothing else is affected.
</Note>

## Connect from Cencori

You can also start the connection from Cencori instead. In the Cencori console,
open **Settings > Integrations > CostGraph** and follow the prompts. Cencori then
pushes the same records to CostGraph, so you have no key to paste here. See
[Cencori's CostGraph guide](https://cencori.com/docs/integrations/costgraph) for
the steps on their side.

## Run the exporter

To keep the usage export key inside your own infrastructure, run our exporter. It
reads Cencori on a schedule and pushes the records for you. Run it in a
container, a Kubernetes `CronJob`, or a binary on a machine you already have.

```bash theme={null}
focus-exporter --provider cencori --sink costgraph
```

Only the finished FOCUS records reach CostGraph.
[Run the exporter](/costgraph/integrations/exporter) covers the three ways to run
it and the variables it reads. To build the request yourself, see
[Push FOCUS data](/costgraph/integrations/focus-push).

## Calls made with your own provider key

When a call runs on your own provider key, the model maker bills you for it, not
Cencori. Those calls land in CostGraph at zero cost, so your Cencori spend shows
only what Cencori billed. The amount the model maker charged is kept
separately on the record in `x_UpstreamProviderCost`.

If you also connect that model maker, for example [Anthropic](/costgraph/integrations/anthropic)
or [OpenAI](/costgraph/integrations/openai), its bill carries the real charge and
nothing is counted twice.

## Cache reads

Each record carries `x_CacheReadTokens` beside `x_InputTokens`. Comparing the two
shows how much of each prompt Cencori served from cache, which is one of the
largest levers on token spend.

A non-zero `x_UnsplitRequests` means Cencori could not split some requests into
input and cache tokens, so the token columns undercount for that record.

## What CostGraph does with it

Records land as raw billing rows, are normalised into line items, and roll up into
daily cost. From there Cencori spend appears in Cost Overview and in anomaly
detection alongside every other provider. Group by sub-account to see spend per
project, end user, or tenant.

[Cencori usage export](https://cencori.com/docs/platform/usage-export) describes
the export on Cencori's side.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.