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

# Configurar features

> Definí capacidades y consultá el acceso actual o el consumo propuesto de un customer.

Las features son capacidades reutilizables que pueden asociarse a varios planes con diferentes límites y precios.

## Tipos de feature

| Tipo | Para qué sirve |
| - | - |
| `boolean` | Capacidades on/off como SSO |
| `usage` | Cantidades medidas como llamadas a la API |
| `seats` | Licencias por usuario |
| `quota` | Balances enteros durables que pueden subir y bajar |

El código de la feature es el identificador que usan Feature Access, Usage, Seats y Quota. Usá letras minúsculas, números y guiones bajos.

## Estado actual de una feature

Usá `featureAccess.get` para leer si el customer tiene acceso actualmente y los contadores de la feature:

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

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

  const featureAccess = await commet.featureAccess.get({
    code: "api_calls",
    customerId: "user_123",
  });
  ```

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

  commet = Commet("ck_xxx")

  feature_access = commet.feature_access.get(
      "api_calls",
      customer_id="user_123",
  )
  ```

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

  featureAccess, err := client.FeatureAccess.Get(ctx, "api_calls", &commet.GetFeatureAccessParams{
  	CustomerID: "user_123",
  })
  if err != nil {
  	log.Fatal(err)
  }
  ```

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

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

  var featureAccess = commet.featureAccess().get(
      "api_calls",
      GetFeatureAccessParams.builder("user_123").build()
  );
  ```

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

  $commet = new Commet('ck_xxx');

  $featureAccess = $commet->featureAccess->get(
      code: 'api_calls',
      customerId: 'user_123',
  );
  ```
</CodeGroup>

La response exacta se discrimina por el `type` de feature. Puede incluir estado habilitado, uso, unidades incluidas, unidades restantes, seats o valores de quota.

Usá la operación de lista para obtener el estado actual completo de features del customer:

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

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

  const response = await commet.featureAccess.list({ customerId: "user_123" });
  ```

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

  commet = Commet("ck_xxx")

  feature_access_list_result = commet.feature_access.list(customer_id="user_123")
  ```

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

  featureAccessListResult, err := client.FeatureAccess.List(ctx, &commet.ListFeatureAccessParams{
  	CustomerID: "user_123",
  })
  if err != nil {
  	log.Fatal(err)
  }
  ```

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

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

  var featureAccessListResult = commet.featureAccess().list(
      ListFeatureAccessParams.builder("user_123").build()
  );
  ```

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

  $commet = new Commet('ck_xxx');

  $featureAccessListResult = $commet->featureAccess->list(customerId: 'user_123');
  ```
</CodeGroup>

Las listas de Feature Access devuelven el envelope estándar `{ object, data, hasMore, nextCursor }`.

## Consumo propuesto

Usá `usage.check` antes de una acción cuando necesites saber si se puede consumir una cantidad y cuánto costaría:

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

La response se discrimina según el consumption model del plan:

* `metered` informa uso actual, restante, incluido y precio de overage.
* `credits` informa el costo estimado en créditos y los pools disponibles.
* `balance` informa el monto monetario estimado y el balance actual.

No uses Feature Access como reemplazo de este check. Feature Access describe el estado actual; Usage Check evalúa el consumo propuesto.

## Registrar el consumo

Cuando la acción termina correctamente, registrala mediante Usage:

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

Usá el `eventId` controlado por quien llama para identificar el evento de negocio cuando los reintentos deban deduplicarlo. La idempotencia del request es una opción separada de transporte que se convierte en `Idempotency-Key`.

## Relacionado

* [Registrar uso](/docs/es/track-usage)
* [Consumption Models](/docs/es/consumption-models)
* [Administrar seats](/docs/es/seat-management)
* [Administrar quota](/docs/es/quota-management)


## Related topics

- [Administrar planes](/docs/es/create-plans.md)
- [Cobro por Tokens de IA](/docs/es/ai-token-billing.md)
- [Gestión de Quota](/docs/es/quota-management.md)
- [Registrar uso](/docs/es/track-usage.md)
- [Gestión de Licencias](/docs/es/seat-management.md)


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