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

# Cobro por Tokens de IA

> Mide y cobra el uso de tokens de IA automáticamente con precios por modelo y márgenes configurables.

El Cobro por Tokens de IA te permite cobrarles a tus clientes en base a los tokens reales que consumen del modelo de IA. Commet mantiene un catálogo con más de 180 precios de modelos de IA, calcula el costo por request, aplica tu margen y lo descuenta del balance del cliente. Solo disponible para planes que usan el modelo de consumo **Balance** ([modelos de consumo](/docs/es/consumption-models)).

## Cómo funciona

1. Tu app llama a un modelo de IA (GPT-4o, Claude, Gemini, etc.)
2. Reportas los tokens consumidos a Commet
3. Commet busca el precio por token del modelo, aplica tu margen y descuenta del balance del cliente
4. Al fin del ciclo de cobro, cualquier sobregiro se cobra como overage

## Setup

### 1. Crea una feature

Ve a **Features**, crea una feature metered (por ejemplo, nombre: "AI Chat", código: `ai_chat`).

### 2. Agrégala a un plan Balance con pricing de AI Model

Ve a **Planes**, abre un plan con modelo de consumo Balance y agrega la feature. Selecciona **AI Model** como modo de pricing y define tu porcentaje de margen.

| Configuración | Descripción |
| - | - |
| **Pricing Mode** | Elige "AI Model" en vez de "Fixed Price" |
| **Margin** | Tu margen sobre el costo del modelo (por ejemplo, 20%) |

### 3. Trackea el uso

Pasa `model`, `inputTokens` y `outputTokens` al trackear. Commet se encarga del resto.

## Trackear tokens de IA con el SDK

Usá el mismo método `track()` en todos los SDKs. Cuando enviás `model`, Commet cambia a pricing por tokens de IA.

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    await commet.usage.track({
      customerId: "user_123",
      featureCode: "ai_chat",
      model: "gpt-4o",
      inputTokens: 1500,
      outputTokens: 300,
    })
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    commet.usage.track(
        customer_id="user_123",
        feature_code="ai_chat",
        model="gpt-4o",
        input_tokens=1500,
        output_tokens=300,
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    inputTokens := 1500
    outputTokens := 300
    model := "gpt-4o"
    client.Usage.Track(ctx, &commet.TrackUsageParams{
        FeatureCode:  "ai_chat",
        CustomerID:   "user_123",
        Model:        &model,
        InputTokens:  &inputTokens,
        OutputTokens: &outputTokens,
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    commet.usage().track(
        TrackUsageParams.builder("ai_chat", "user_123")
            .model("gpt-4o")
            .inputTokens(1500L)
            .outputTokens(300L)
            .build()
    );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    $commet->usage->track(
        featureCode: 'ai_chat',
        model: 'gpt-4o',
        inputTokens: 1500,
        outputTokens: 300,
        customerId: 'user_123',
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -X POST https://commet.co/api/v1/usage/events \
      -H "x-api-key: $COMMET_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "featureCode": "ai_chat",
        "customerId": "user_123",
        "model": "gpt-4o",
        "inputTokens": 1500,
        "outputTokens": 300
      }'
    ```
  </Tab>
</Tabs>

Para modelos con prompt caching, incluye los cache tokens para un cobro preciso:

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    await commet.usage.track({
      customerId: "user_123",
      featureCode: "ai_chat",
      model: "anthropic/claude-sonnet-4.6",
      inputTokens: 10000,
      outputTokens: 2000,
      cacheReadTokens: 7000,
      cacheWriteTokens: 1000,
    })
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    commet.usage.track(
        customer_id="user_123",
        feature_code="ai_chat",
        model="anthropic/claude-sonnet-4.6",
        input_tokens=10000,
        output_tokens=2000,
        cache_read_tokens=7000,
        cache_write_tokens=1000,
    )
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    inputTokens := 10000
    outputTokens := 2000
    cacheReadTokens := 7000
    cacheWriteTokens := 1000
    model := "anthropic/claude-sonnet-4.6"
    client.Usage.Track(ctx, &commet.TrackUsageParams{
        FeatureCode:     "ai_chat",
        CustomerID:       "user_123",
        Model:            &model,
        InputTokens:      &inputTokens,
        OutputTokens:     &outputTokens,
        CacheReadTokens:  &cacheReadTokens,
        CacheWriteTokens: &cacheWriteTokens,
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    commet.usage().track(
        TrackUsageParams.builder("ai_chat", "user_123")
            .model("anthropic/claude-sonnet-4.6")
            .inputTokens(10000L)
            .outputTokens(2000L)
            .cacheReadTokens(7000L)
            .cacheWriteTokens(1000L)
            .build()
    );
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    $commet->usage->track(
        featureCode: 'ai_chat',
        model: 'anthropic/claude-sonnet-4.6',
        inputTokens: 10000,
        outputTokens: 2000,
        customerId: 'user_123',
        cacheReadTokens: 7000,
        cacheWriteTokens: 1000,
    );
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={null}
    curl -X POST https://commet.co/api/v1/usage/events \
      -H "x-api-key: $COMMET_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "featureCode": "ai_chat",
        "customerId": "user_123",
        "model": "anthropic/claude-sonnet-4.6",
        "inputTokens": 10000,
        "outputTokens": 2000,
        "cacheReadTokens": 7000,
        "cacheWriteTokens": 1000
      }'
    ```
  </Tab>
</Tabs>

<Note>
  Los cache read tokens son mucho más baratos que los input tokens regulares. Commet cotiza cada tipo de token por separado para que los clientes paguen tarifas justas.
</Note>

## Tracking automático con `@commet/ai-sdk`

Si usas el [Vercel AI SDK](https://ai-sdk.dev) (solo Node.js), instala `@commet/ai-sdk` para trackear tokens automáticamente.

```bash theme={null}
npm install @commet/ai-sdk
```

Envuelve tu modelo con `tracked()`. Cada llamada a `generateText` y `streamText` se trackea sin código extra.

```typescript theme={null}
import { tracked } from "@commet/ai-sdk"
import { Commet } from "@commet/node"
import { openai } from "@ai-sdk/openai"
import { generateText } from "ai"

const commet = new Commet({ apiKey: process.env.COMMET_API_KEY! })

const model = tracked(openai("gpt-4o"), {
  commet,
  feature: "ai_chat",
  customerId: "user_123",
})

const result = await generateText({ model, prompt: "Hello!" })
// Tokens trackeados y balance descontado automáticamente
```

Funciona con cualquier provider del AI SDK: OpenAI, Anthropic, Google y cualquier modelo disponible a través del Vercel AI Gateway.

## Parámetros

| Parámetro | Tipo | Requerido | Descripción |
| - | - | - | - |
| `featureCode` | `string` | Sí | Código de evento de una feature metered |
| `customerId` | `string` | Sí | ID del cliente en Commet (`cus_xxx`) o tu ID externo |
| `model` | `string` | Sí | Identificador del modelo de IA (por ejemplo, `gpt-4o`, `anthropic/claude-sonnet-4.6`) |
| `inputTokens` | `number` | Sí | Cantidad de tokens de input (prompt) |
| `outputTokens` | `number` | Sí | Cantidad de tokens de output (completion) |
| `cacheReadTokens` | `number` | No | Tokens de input cacheados leídos (tarifa más barata) |
| `cacheWriteTokens` | `number` | No | Tokens de input cacheados escritos (tarifa más cara) |
| `eventId` | `string` | No | ID del evento controlado por quien llama para deduplicar reintentos |

## Formatos del identificador de modelo

Commet acepta identificadores de modelo en dos formatos:

| Formato | Ejemplo | Cuándo usar |
| - | - | - |
| Solo Model ID | `gpt-4o` | Uso directo del SDK del provider |
| Provider/Model | `anthropic/claude-sonnet-4.6` | Setups con AI Gateway o multi-provider |

## Cálculo del costo

Para cada request, Commet calcula:

```
inputCost  = nonCachedInputTokens  x  inputPrice  / 1M
outputCost = outputTokens          x  outputPrice / 1M
cacheCost  = cacheReadTokens       x  cachePrice  / 1M
             + cacheWriteTokens    x  cacheWritePrice / 1M
subtotal   = inputCost + outputCost + cacheCost
total      = subtotal  x  (1 + margin%)
```

## Catálogo de modelos de IA

Commet mantiene un catálogo de más de 180 modelos de IA con precios por token actualizados, sincronizados a diario desde el Vercel AI Gateway. El catálogo incluye precios de input, output, cache read y cache write para cada modelo.

Los providers soportados incluyen OpenAI, Anthropic, Google, Meta, Mistral, Cohere y más.

## Dashboard de Costos de IA

Ve todos los costos de tokens de IA en el dashboard bajo **AI Costs**. Cada entrada muestra el modelo usado, el desglose de tokens, el cálculo del costo, el margen aplicado y el total cobrado.

## Relacionado

* [Modelos de Consumo](/docs/es/consumption-models) — Cómo funciona el modelo Balance
* [Trackear Uso](/docs/es/track-usage) — Tracking de uso estándar
* [Configurar Features](/docs/es/configure-features) — Crea features metered


## Related topics

- [Modelos de consumo](/docs/es/consumption-models.md)
- [Ejemplos](/docs/es/examples.md)
- [Registrar uso](/docs/es/track-usage.md)
- [Skill Pricing Models](/docs/es/pricing-models-skill.md)
- [Recibos y ciclos de cobro](/docs/es/invoices-and-billing-cycles.md)


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