> ## 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.

# Registrar uso

> Registrá consumo medido con los SDKs actuales de Commet.

Cada feature medida tiene un único código. Enviá ese código como `featureCode`; Commet agrega los eventos para acceso, credits, balance y facturación.

## Registrar un evento

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { Commet } from "@commet/node";

  const commet = new Commet({ apiKey: "ck_xxx" });

  const usageEvent = await commet.usage.track({
    featureCode: "api_calls",
    customerId: "user_123",
    model: "example",
    inputTokens: 1,
    outputTokens: 1,
  });
  ```

  ```python Python theme={null}
  from commet import Commet

  commet = Commet("ck_xxx")

  usage_event = commet.usage.track(
      feature_code="api_calls",
      customer_id="user_123",
      model="example",
      input_tokens=1,
      output_tokens=1,
  )
  ```

  ```go Go theme={null}
  client, err := commet.New("ck_xxx")
  if err != nil {
  	log.Fatal(err)
  }
  ctx := context.Background()

  usageEvent, err := client.Usage.Track(ctx, &commet.TrackUsageParams{
  	FeatureCode: "api_calls",
  	CustomerID: "user_123",
  	Model: func(value string) *string { return &value }("example"),
  	InputTokens: func(value int) *int { return &value }(1),
  	OutputTokens: func(value int) *int { return &value }(1),
  })
  if err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java theme={null}
  import co.commet.Commet;
  import co.commet.params.TrackUsageParams;

  var commet = Commet.builder().apiKey("ck_xxx").build();

  var usageEvent = commet.usage().track(
      TrackUsageParams.builder("api_calls", "user_123").model("example").inputTokens(1L).outputTokens(1L).build()
  );
  ```

  ```php PHP theme={null}
  use Commet\Commet;

  $commet = new Commet('ck_xxx');

  $usageEvent = $commet->usage->track(
      featureCode: 'api_calls',
      customerId: 'user_123',
      model: 'example',
      inputTokens: 1,
      outputTokens: 1,
  );
  ```
</CodeGroup>

El request acepta:

| Campo | Requerido | Significado |
| - | - | - |
| `featureCode` | Sí | Código de la feature medida |
| `customerId` | Sí | ID del customer en Commet o tu ID estable |
| `value` | No | Cantidad numérica; por defecto es uno en eventos normales |
| `eventId` | No | ID del evento de negocio controlado por quien llama para deduplicar reintentos |
| `timestamp` | No | Fecha ISO 8601 del evento; por defecto es ahora |
| `properties` | No | Propiedades string para atribución y debugging |

Los eventos de modelos de IA usan la misma operación, pero envían `model`, `inputTokens` y `outputTokens` en lugar de `value`.

## ID del evento de negocio e idempotencia del request

`eventId` identifica el evento de consumo en tu sistema. Reutilizalo cuando reintentes el mismo evento.

La idempotencia del request protege una mutación HTTP y se pasa mediante las opciones del SDK como `idempotencyKey`. Se convierte en el header `Idempotency-Key`. No envíes esa clave de transporte dentro del body de uso.

```typescript theme={null}
await commet.usage.track(
  {
    featureCode: 'api_calls',
    customerId: 'user_123',
    value: 1,
    eventId: 'request_01JXYZ',
  },
  { idempotencyKey: 'delivery_01JXYZ' },
)
```

## Corregir el uso del período actual

Usá `set` cuando tu fuente de verdad necesite reemplazar el total medido actual:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { Commet } from "@commet/node";

  const commet = new Commet({ apiKey: "ck_xxx" });

  const usageAdjustment = await commet.usage.set({
    customerId: "user_123",
    featureCode: "api_calls",
    value: 1,
  });
  ```

  ```python Python theme={null}
  from commet import Commet

  commet = Commet("ck_xxx")

  usage_adjustment = commet.usage.set(
      customer_id="user_123",
      feature_code="api_calls",
      value=1,
  )
  ```

  ```go Go theme={null}
  client, err := commet.New("ck_xxx")
  if err != nil {
  	log.Fatal(err)
  }
  ctx := context.Background()

  usageAdjustment, err := client.Usage.Set(ctx, &commet.SetUsageParams{
  	CustomerID: "user_123",
  	FeatureCode: "api_calls",
  	Value: 1,
  })
  if err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java theme={null}
  import co.commet.Commet;
  import co.commet.params.SetUsageParams;

  var commet = Commet.builder().apiKey("ck_xxx").build();

  var usageAdjustment = commet.usage().set(
      SetUsageParams.builder("user_123", "api_calls", 1L).build()
  );
  ```

  ```php PHP theme={null}
  use Commet\Commet;

  $commet = new Commet('ck_xxx');

  $usageAdjustment = $commet->usage->set(
      customerId: 'user_123',
      featureCode: 'api_calls',
      value: 1,
  );
  ```
</CodeGroup>

`value` es el total deseado, no un delta. Commet registra un ajuste con signo y conserva el historial original de eventos. Esta operación aplica solamente al período medido activo.

## Verificar antes de consumir

Cuando el acceso o costo dependan de la cantidad propuesta, llamá a Usage Check antes de ejecutar la acción:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { Commet } from "@commet/node";

  const commet = new Commet({ apiKey: "ck_xxx" });

  const usageCheck = await commet.usage.check({
    customerId: "user_123",
    featureCode: "api_calls",
  });
  ```

  ```python Python theme={null}
  from commet import Commet

  commet = Commet("ck_xxx")

  usage_check = commet.usage.check(
      customer_id="user_123",
      feature_code="api_calls",
  )
  ```

  ```go Go theme={null}
  client, err := commet.New("ck_xxx")
  if err != nil {
  	log.Fatal(err)
  }
  ctx := context.Background()

  usageCheck, err := client.Usage.Check(ctx, &commet.CheckUsageAvailabilityParams{
  	CustomerID: "user_123",
  	FeatureCode: "api_calls",
  })
  if err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java theme={null}
  import co.commet.Commet;
  import co.commet.params.CheckUsageAvailabilityParams;

  var commet = Commet.builder().apiKey("ck_xxx").build();

  var usageCheck = commet.usage().check(
      CheckUsageAvailabilityParams.builder("user_123", "api_calls").build()
  );
  ```

  ```php PHP theme={null}
  use Commet\Commet;

  $commet = new Commet('ck_xxx');

  $usageCheck = $commet->usage->check(
      customerId: 'user_123',
      featureCode: 'api_calls',
  );
  ```
</CodeGroup>

## Relacionado

* [Configurar features](/docs/es/configure-features)
* [Facturación de tokens de IA](/docs/es/ai-token-billing)
* [Consumption Models](/docs/es/consumption-models)


## Related topics

- [Configurar features](/docs/es/configure-features.md)
- [Addons](/docs/es/add-ons.md)
- [Política de uso aceptable](/docs/es/acceptable-use.md)
- [Métricas y eventos de uso](/docs/es/dashboard-metrics-and-events.md)
- [Manejo de errores](/docs/es/error-handling.md)


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