> ## Documentation Index
> Fetch the complete documentation index at: https://trophy-ci-i18n-auto-translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Autenticación

> Autentícate con la API de la aplicación usando claves de API de aplicación con ámbito de usuario transmitidas en el encabezado `X-API-KEY`.

<h2 id="api-key-types">
  Tipos de clave de API
</h2>

La API de la aplicación acepta dos tipos de claves de API:

| Tipo de clave                                                  | Ámbito             | Dónde usar                                  | ¿Segura del lado del cliente? |
| -------------------------------------------------------------- | ------------------ | ------------------------------------------- | ----------------------------- |
| [Claves de API de aplicación](#application-api-keys)           | Usuario individual | Solo API de la aplicación                   | Sí                            |
| [Claves de API de administrador](/es/admin-api/authentication) | Cuenta completa    | API de la aplicación y API de administrador | No                            |

Usa claves de API de aplicación cuando desees que los usuarios finales o las aplicaciones cliente llamen a la API de la aplicación con permisos limitados a un solo usuario. Usa [claves de API de administrador](/es/admin-api/authentication) para integraciones de servidor confiables que requieran acceso amplio.

<h2 id="application-api-keys">
  Claves de API de aplicación
</h2>

Las claves de API de aplicación tienen ámbito de un usuario específico. Cada clave solo puede realizar operaciones de la API de la aplicación en nombre del usuario para el que fue creada, lo que las hace seguras para exponerlas en entornos del lado del cliente.

Las claves de API de aplicación no se pueden usar con la API de administrador.

<h3 id="creating-application-api-keys">
  Crear claves de API de aplicación
</h3>

Crea claves de API de aplicación con la [API de administrador](/es/admin-api/endpoints/application-api-keys/create-application-api-keys). Autentícate en esa solicitud con una [clave de API de administrador](/es/admin-api/authentication).

Puedes crear claves para hasta 100 usuarios por solicitud. El valor completo de la clave se devuelve una sola vez en el momento de la creación y no se puede recuperar nuevamente—guárdala de forma segura o entrégala al cliente de inmediato.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST https://admin.trophy.so/v1/application-api-keys \
       -H "X-API-KEY: <api-key>" \
       -H "Content-Type: application/json" \
       -d '[
         { "userId": "user_123" },
         { "userId": "user_456" }
       ]'
  ```

  ```typescript Node theme={null}
  await trophy.admin.applicationApiKeys.create([
    { userId: "user_123" },
    { userId: "user_456" },
  ]);
  ```

  ```python Python theme={null}
  client.admin.application_api_keys.create(
      request=[
          CreateApplicationKeyRequestItem(
              user_id="user_123",
          ),
          CreateApplicationKeyRequestItem(
              user_id="user_456",
          ),
      ],
  )
  ```

  ```php PHP theme={null}
  $trophy->admin->applicationApiKeys->create([
      ['userId' => 'user_123'],
      ['userId' => 'user_456'],
  ]);
  ```

  ```java Java theme={null}
  CreateApplicationKeysResponse response = client.admin().applicationApiKeys().create(
    List.of(
      CreateApplicationKeyRequestItem.builder().userId("user_123").build(),
      CreateApplicationKeyRequestItem.builder().userId("user_456").build()
    )
  );
  ```

  ```go Go theme={null}
  response, err := client.Admin.ApplicationApiKeys.Create(
      context.TODO(),
      []*api.CreateApplicationKeyRequestItem{
          {UserId: "user_123"},
          {UserId: "user_456"},
      },
  )
  ```

  ```csharp C# theme={null}
  await trophy.Admin.ApplicationApiKeys.CreateAsync(new[]
  {
      new CreateApplicationKeyRequestItem { UserId = "user_123" },
      new CreateApplicationKeyRequestItem { UserId = "user_456" },
  });
  ```

  ```ruby Ruby theme={null}
  result = client.admin.application_api_keys.create([
    { user_id: 'user_123' },
    { user_id: 'user_456' }
  ])
  ```
</CodeGroup>

Una respuesta exitosa incluye el ID de la clave (utilizado posteriormente para eliminar la clave), el ID de usuario, la clave completa y un prefijo legible:

```json theme={null}
{
  "created": [
    {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "userId": "user_123",
      "key": "app_XXXXX.YOUR_API_KEY",
      "prefix": "app_XXXXX"
    }
  ],
  "issues": []
}
```

<h3 id="anatomy-of-an-application-api-key">
  Anatomía de una clave de API de aplicación
</h3>

Cada clave de API de aplicación se compone de 2 partes separadas por un punto:

```bash theme={null}
{prefix}.{body}
```

* El *prefijo* identifica la clave (por ejemplo `app_XXXXX`) y es seguro para registrar o mostrar.
* El *cuerpo* es la parte secreta, y solo se muestra una vez cuando creas la clave.

<Note>
  Al usar el API, ambas partes de tu clave de API de aplicación deben enviarse en el encabezado
  `X-API-KEY`.
</Note>

<h3 id="authenticating-requests">
  Autenticación de solicitudes
</h3>

Incluye la clave de API de aplicación completa en el encabezado `X-API-KEY` en las solicitudes del Application API, o pásala al inicializar un cliente SDK. La clave solo autoriza operaciones para el usuario al que está vinculada; las solicitudes para otros usuarios devuelven un error.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.trophy.so/v1/users/user_123/metrics/<key> \
       -H "X-API-KEY: YOUR_API_KEY"
  ```

  ```typescript Node theme={null}
  import { TrophyApiClient } from "@trophyso/node";

  const trophy = new TrophyApiClient({
    apiKey: "YOUR_API_KEY",
  });
  ```

  ```python Python theme={null}
  from trophy import TrophyApi

  client = TrophyApi(
      api_key="YOUR_API_KEY",
  )
  ```

  ```php PHP theme={null}
  use Trophy\TrophyClient;

  $trophy = new TrophyClient("YOUR_API_KEY");
  ```

  ```java Java theme={null}
  TrophyApiClient client = TrophyApiClient.builder()
      .apiKey("YOUR_API_KEY")
      .build();
  ```

  ```go Go theme={null}
  import (
    trophyclient "github.com/trophyso/trophy-go/client"
    "github.com/trophyso/trophy-go/option"
  )

  client := trophyclient.NewClient(
    option.WithApiKey("YOUR_API_KEY"),
  )
  ```

  ```csharp C# theme={null}
  var trophy = new TrophyApiClient(
      apiKey: "YOUR_API_KEY"
  );
  ```

  ```ruby Ruby theme={null}
  client = Trophy::Client.new(
    api_key: "YOUR_API_KEY"
  )
  ```
</CodeGroup>

Si no proporcionas una clave de API, o tu clave de API no es válida, recibirás un código de respuesta `401`.

<h3 id="deleting-application-api-keys">
  Eliminación de claves de API de aplicación
</h3>

Elimina las claves de API de aplicación por ID con el [Admin API](/es/admin-api/endpoints/application-api-keys/delete-application-api-keys). Usa el UUID devuelto cuando se creó la clave.

<CodeGroup>
  ```bash cURL theme={null}
  curl -X DELETE "https://admin.trophy.so/v1/application-api-keys?ids=550e8400-e29b-41d4-a716-446655440000" \
       -H "X-API-KEY: <api-key>"
  ```

  ```typescript Node theme={null}
  await trophy.admin.applicationApiKeys.delete({
    ids: ["550e8400-e29b-41d4-a716-446655440000"],
  });
  ```

  ```python Python theme={null}
  client.admin.application_api_keys.delete(
      ids=["550e8400-e29b-41d4-a716-446655440000"],
  )
  ```

  ```php PHP theme={null}
  $trophy->admin->applicationApiKeys->delete([
      'ids' => ['550e8400-e29b-41d4-a716-446655440000'],
  ]);
  ```

  ```java Java theme={null}
  DeleteApplicationKeysResponse response = client.admin().applicationApiKeys().delete(
    ApplicationApiKeysDeleteRequest.builder()
      .ids(List.of("550e8400-e29b-41d4-a716-446655440000"))
      .build()
  );
  ```

  ```go Go theme={null}
  response, err := client.Admin.ApplicationApiKeys.Delete(
      context.TODO(),
      &admin.ApplicationApiKeysDeleteRequest{
          Ids: []*string{
              api.String("550e8400-e29b-41d4-a716-446655440000"),
          },
      },
  )
  ```

  ```csharp C# theme={null}
  await trophy.Admin.ApplicationApiKeys.DeleteAsync(new ApplicationApiKeysDeleteRequest
  {
      Ids = new[] { "550e8400-e29b-41d4-a716-446655440000" },
  });
  ```

  ```ruby Ruby theme={null}
  result = client.admin.application_api_keys.delete(
    ids: ['550e8400-e29b-41d4-a716-446655440000']
  )
  ```
</CodeGroup>

<Error>Una vez que las claves de API se eliminan, no se pueden recuperar.</Error>

<h2 id="get-support">
  Obtener soporte
</h2>

¿Quieres ponerte en contacto con el equipo de Trophy? Comunícate con nosotros por [correo electrónico](mailto:support@trophy.so). ¡Estamos aquí para ayudarte!