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

# Autenticación

> Autentícate en la API de MKA1 con tu clave API, decide cuándo enviar X-On-Behalf-Of e intercambia una clave API por un JWT de corta duración.

Utiliza tu clave API de MKA1 en el encabezado `Authorization` en cada solicitud.
Para integraciones de servidor multiusuario, también envía `X-On-Behalf-Of` para identificar al usuario final.

<Tip>
  ¿Necesitas la ruta completa de la solicitud, reglas de propagación de encabezados y detalles internos del intercambio de JWT?
  Lee la [explicación detallada de autenticación](/es/docs/authentication-deep-dive).
</Tip>

## Envía tu clave API

Pasa tu clave API como un token bearer.

```http theme={null}
Authorization: Bearer <mka1-api-key>
```

Utiliza `https://apigw.mka1.com` como la URL base.

<CodeGroup>
  ```bash CLI theme={null}
  export MKA1_BEARER_AUTH='Bearer <mka1-api-key>'

  mka1 whoami -H 'X-On-Behalf-Of: <end-user-id>'
  ```

  ```ts MKA1 SDK theme={null}
  import { SDK } from '@meetkai/mka1'

  const mka1 = new SDK({ bearerAuth: 'Bearer YOUR_API_KEY' })

  const response = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Write a short welcome message.',
  })
  ```

  ```ts OpenAI SDK theme={null}
  import OpenAI from 'openai'

  const openai = new OpenAI({
    apiKey: 'YOUR_API_KEY',
    baseURL: 'https://apigw.mka1.com/api/v1/llm/',
  })

  const response = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Write a short welcome message.',
  })
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;

  var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Input = ResponsesCreateRequestInput.CreateStr("Write a short welcome message."),
  });
  ```

  ```python Python SDK theme={null}
  from mka1 import SDK

  sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      input="Write a short welcome message.",
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --data '{
      "model": "meetkai:functionary-es-mini",
      "input": "Write a short welcome message."
    }'
  ```
</CodeGroup>

Si tu clave API falta, es inválida o no tiene acceso al recurso solicitado, la API de MKA1 devolverá un error de autenticación o autorización.

## Envía `X-On-Behalf-Of` para un usuario final

Utiliza `X-On-Behalf-Of` cuando tu servidor realice una solicitud en nombre de uno de tus usuarios finales.
Establece el valor del encabezado como tu propio identificador estable de usuario final.

```http theme={null}
X-On-Behalf-Of: <end-user-id>
```

Por ejemplo, si tu aplicación almacena usuarios como `user_123`, utiliza ese valor de manera consistente en las solicitudes realizadas para ese usuario.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 whoami -H 'X-On-Behalf-Of: user_123'
  ```

  ```ts MKA1 SDK theme={null}
  import { SDK } from '@meetkai/mka1'

  const mka1 = new SDK({ bearerAuth: 'Bearer YOUR_API_KEY' })

  const response = await mka1.llm.responses.create(
    {
      model: 'meetkai:functionary-es-mini',
      input: 'Summarize this support ticket.',
    },
    {
      headers: { 'X-On-Behalf-Of': 'user_123' },
    }
  )
  ```

  ```ts OpenAI SDK theme={null}
  import OpenAI from 'openai'

  const openai = new OpenAI({
    apiKey: 'YOUR_API_KEY',
    baseURL: 'https://apigw.mka1.com/api/v1/llm/',
    defaultHeaders: { 'X-On-Behalf-Of': 'user_123' },
  })

  const response = await openai.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Summarize this support ticket.',
  })
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;

  var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Input = ResponsesCreateRequestInput.CreateStr("Summarize this support ticket."),
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="meetkai:functionary-es-mini",
      input="Summarize this support ticket.",
      http_headers={"X-On-Behalf-Of": "user_123"},
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: user_123' \
    --data '{
      "model": "meetkai:functionary-es-mini",
      "input": "Summarize this support ticket."
    }'
  ```
</CodeGroup>

Si tu integración no actúa para un usuario final específico, omite `X-On-Behalf-Of`.

## Elige el patrón correcto

Utiliza solo `Authorization` cuando:

* Estás llamando a la API de MKA1 para tu propio flujo de trabajo backend.
* La solicitud no está asociada a un usuario final específico.

Utiliza tanto `Authorization` como `X-On-Behalf-Of` cuando:

* Tu servidor actúa en nombre de uno de tus usuarios finales.
* Quieres que las solicitudes, respuestas, archivos o el uso permanezcan asociados a ese usuario final.

No envíes una dirección de correo electrónico o un nombre visible mutable a menos que ya sea tu identificador estable de usuario final.
Utiliza un ID de tu propio sistema que no cambie.

## Intercambia una clave API por un JWT

Utiliza `POST /api/v1/authentication/api-key/exchange-token` cuando necesites un JWT de corta duración para un servicio downstream.
Envía tu clave API de MKA1 en `Authorization`.
Luego, pasa un cuerpo JSON con:

* `audience`: La URL del servicio que debe aceptar el token.
* `externalUserId`: Tu ID de usuario final para el sujeto del JWT.
* `expiresIn`: Duración opcional del token en segundos. La especificación OpenAPI permite de 300 a 2592000.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 auth api-key get-jwt-from-key \
    --audience https://my-awesome-website.com \
    --external-user-id user_123 \
    --expires-in 3600
  ```

  ```ts MKA1 SDK theme={null}
  import { SDK } from '@meetkai/mka1'

  const mka1 = new SDK({ bearerAuth: 'Bearer YOUR_API_KEY' })

  const result = await mka1.auth.apiKey.exchangeToken({
    audience: 'https://my-awesome-website.com',
    externalUserId: 'user_123',
    expiresIn: 3600,
  })
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(bearerAuth: "Bearer YOUR_API_KEY");

  var result = await sdk.Auth.ApiKey.GetJwtFromKeyAsync(
      xOnBehalfOf: "<end-user-id>",
      body: new GetJwtFromKeyRequestBody()
      {
          Audience = "https://my-awesome-website.com",
          ExternalUserId = "user_123",
          ExpiresIn = 3600,
      });

  Console.WriteLine(result.Object!.Token);
  ```

  ```python Python SDK theme={null}
  jwt = sdk.auth.api_key.get_jwt_from_key()

  # Usa el JWT para solicitudes posteriores
  authed = SDK(bearer_auth=f"Bearer {jwt.token}")
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/authentication/api-key/exchange-token \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --data '{
      "audience": "https://my-awesome-website.com",
      "externalUserId": "user_123",
      "expiresIn": 3600
    }'
  ```
</CodeGroup>

Una respuesta exitosa devuelve un objeto JSON con `token`.

## Usa un JWT para solicitudes posteriores

Una vez que tengas un JWT del endpoint de intercambio, utilízalo como token bearer en lugar de tu clave API.
Esto te permite emitir credenciales de corta duración a servicios downstream o usuarios finales sin exponer tu clave API.

<CodeGroup>
  ```bash CLI theme={null}
  # Pasa el JWT explícitamente vía -H para sobrescribir MKA1_BEARER_AUTH
  mka1 llm responses create \
    --model meetkai:functionary-es-mini \
    --input '"Write a short welcome message."' \
    -H 'Authorization: Bearer <jwt-token>'
  ```

  ```ts MKA1 SDK theme={null}
  import { SDK } from '@meetkai/mka1'

  // Usa el JWT devuelto por el endpoint de intercambio
  const mka1 = new SDK({ bearerAuth: `Bearer ${result.token}` })

  const response = await mka1.llm.responses.create({
    model: 'meetkai:functionary-es-mini',
    input: 'Write a short welcome message.',
  })
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;

  // Usa el JWT devuelto por el endpoint de intercambio
  var jwtSdk = new SDK(bearerAuth: $"Bearer {result.Object!.Token}",
      serverUrl: "https://apigw.mka1.com");

  var res = await jwtSdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "meetkai:functionary-es-mini",
      Input = ResponsesCreateRequestInput.CreateStr("Write a short welcome message."),
  });
  ```

  ```python Python SDK theme={null}
  # Usa el JWT devuelto por el endpoint de intercambio
  authed = SDK(bearer_auth=f"Bearer {jwt.token}")

  res = authed.llm.responses.create(
      model="meetkai:functionary-es-mini",
      input="Write a short welcome message.",
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header "Authorization: Bearer <jwt-token>" \
    --data '{
      "model": "meetkai:functionary-es-mini",
      "input": "Write a short welcome message."
    }'
  ```
</CodeGroup>

## Próximos pasos

* Revisa la [visión general de la API](/es/api-reference/introduction) para la URL base y la especificación OpenAPI en vivo.
* Lee la [explicación detallada de autenticación](/es/docs/authentication-deep-dive) para conocer el gateway de extremo a extremo, el intercambio de JWT y el modelo de identidad downstream.
* Aprende cómo controlar el acceso a los recursos con [Autorización](/es/docs/authorization).