Gemini 3.8 Flash ya está disponible. Pruébalo.

Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Credenciales en agentes administrados

Las credenciales son secretos administrados por el servidor que permiten que tus agentes accedan a servicios de terceros sin que el secreto ingrese al entorno del agente. Almacenas una credencial una vez, la referencias por ID y el proxy de salida la resuelve y la inyecta en el momento de la solicitud.

Los valores de los secretos son de solo escritura. Una vez almacenados, ningún extremo los devuelve, por lo que un agente vulnerado no puede leer los tokens que usa.

El lugar principal en el que usas una credencial es la lista de entidades permitidas de la red en environment.network. Primero, almacena el secreto:

Python

from google import genai

client = genai.Client()

credential = client.credentials.create(
    id="github-production",
    type="bearer_token",
    token="ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
)

print(f"Credential ID: {credential.id}, Status: {credential.status}")

JavaScript

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const credential = await client.credentials.create({
    id: "github-production",
    type: "bearer_token",
    token: "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
});

console.log(`Credential ID: ${credential.id}, Status: ${credential.status}`);

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "github-production",
    "type": "bearer_token",
    "token": "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}'

Luego, adjúntalo al dominio que autentica:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Triage the open issues in my-org/my-repo.",
    environment={
        "type": "remote",
        "network": {
            "allowlist": [
                {"domain": "api.github.com", "credential": "github-production"},
                {"domain": "*"},
            ]
        },
    },
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Triage the open issues in my-org/my-repo.",
    environment: {
        type: "remote",
        network: {
            allowlist: [
                { domain: "api.github.com", credential: "github-production" },
                { domain: "*" },
            ],
        },
    },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Triage the open issues in my-org/my-repo.",
    "environment": {
        "type": "remote",
        "network": {
            "allowlist": [
                { "domain": "api.github.com", "credential": "github-production" },
                { "domain": "*" }
            ]
        }
    }
}'

Ahora el agente realiza solicitudes autenticadas a api.github.com, y el token nunca existe dentro del sandbox.

Tipos de credenciales

Cada credencial tiene un type que determina qué campos acepta y cómo el proxy la aplica.

Tipo	Caso de uso	Comportamiento
`bearer_token`	Tokens de acceso personal, tokens de bot y claves de API estáticas	El proxy inserta el token como un encabezado de la solicitud. No hay lógica de actualización.
`oauth2`	Apps de OAuth y flujos delegados por el usuario	El proxy intercambia el token de actualización por tokens de acceso y los actualiza a medida que vencen.
`environment_variable`	SDKs de cliente que leen secretos del entorno del proceso	El entorno del agente recibe un marcador de posición. El proxy sustituye el secreto real en las solicitudes salientes.

Usa credenciales en la lista de entidades permitidas de la red

Agrega credential a una regla de lista de entidades permitidas, y el proxy autenticará cada solicitud saliente a ese dominio. Esta es la forma recomendada de otorgar acceso a un agente a una API privada, un repositorio privado o un bucket privado.

Puedes combinar reglas autenticadas y no autenticadas en la misma lista de entidades permitidas:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Sync the open Jira issues into the tracking sheet in my repo.",
    environment={
        "type": "remote",
        "sources": [
            {
                "type": "repository",
                "source": "https://github.com/your-org/backend",
                "target": "/backend-app",
            }
        ],
        "network": {
            "allowlist": [
                {"domain": "github.com", "credential": "github-production"},
                {"domain": "api.atlassian.com", "credential": "jira-oauth"},
                {"domain": "*.googleapis.com"},
            ]
        },
    },
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Sync the open Jira issues into the tracking sheet in my repo.",
    environment: {
        type: "remote",
        sources: [
            {
                type: "repository",
                source: "https://github.com/your-org/backend",
                target: "/backend-app",
            },
        ],
        network: {
            allowlist: [
                { domain: "github.com", credential: "github-production" },
                { domain: "api.atlassian.com", credential: "jira-oauth" },
                { domain: "*.googleapis.com" },
            ],
        },
    },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Sync the open Jira issues into the tracking sheet in my repo.",
    "environment": {
        "type": "remote",
        "sources": [
            {
                "type": "repository",
                "source": "https://github.com/your-org/backend",
                "target": "/backend-app"
            }
        ],
        "network": {
            "allowlist": [
                { "domain": "github.com", "credential": "github-production" },
                { "domain": "api.atlassian.com", "credential": "jira-oauth" },
                { "domain": "*.googleapis.com" }
            ]
        }
    }
}'

Dado que el proxy resuelve la credencial por solicitud, una credencial de oauth2 actualiza su token de acceso de forma transparente. Una interacción de larga duración no se interrumpe cuando vence el token de acceso.

Cómo combinar `credential` y `transform`

Las reglas de la lista de entidades permitidas también aceptan un objeto transform intercalado que establece encabezados directamente en la regla. El proxy de salida aplica ambos mecanismos en la conexión, por lo que, en ambos casos, el valor del encabezado nunca existe dentro de la zona de pruebas. Ambos campos pueden aparecer en la misma regla.

Configuración de la regla	Comportamiento
`credential` únicamente	El proxy resuelve la credencial y, luego, inserta su encabezado en cada solicitud al dominio.
`transform` únicamente	Se inserta un encabezado estático. Los encabezados que escribas se enviarán tal como los redactaste.
Ambos	Primero se aplica la credencial y, luego, `transform` se combina en la parte superior. Un encabezado `transform` explícito gana si ambos establecen la misma clave.
Neither	El dominio está permitido y no se insertan encabezados.

Vale la pena usar una credencial cuando quieres almacenar un secreto una sola vez y hacer referencia a él desde cada entorno, agente y activador de tu proyecto, y cuando quieres que se controlen la actualización y la rotación del token de acceso por ti. Un transform intercalado se ajusta cuando el valor pertenece a una sola llamada, por ejemplo, un token que generas tú mismo justo antes de crear la interacción.

Es común combinar ambos. La credencial contiene el encabezado de autenticación y transform agrega cualquier otro elemento que el servicio upstream espera en la misma solicitud:

{
    "domain": "api.atlassian.com",
    "credential": "jira-oauth",
    "transform": {
        "X-Atlassian-Workspace": "my-workspace-id"
    }
}

Para mover un secreto de un transform intercalado a una credencial, almacénalo con POST /credentials, reemplaza el encabezado de autorización en transform por "credential": "<id>" y deja el resto del objeto transform como está.

Usa credenciales con servidores de MCP

Los servidores de MCP remotos toman el mismo campo credential. Configúralo en una herramienta mcp_server y el proxy insertará el encabezado de autorización en cada solicitud a ese servidor:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Create a new issue in my-org/my-repo",
    environment="remote",
    tools=[{
        "type": "mcp_server",
        "name": "github",
        "url": "https://api.githubcopilot.com/mcp",
        "credential": "github-production",
    }],
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Create a new issue in my-org/my-repo",
    environment: "remote",
    tools: [{
        type: "mcp_server",
        name: "github",
        url: "https://api.githubcopilot.com/mcp",
        credential: "github-production",
    }],
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Create a new issue in my-org/my-repo",
    "environment": "remote",
    "tools": [
        {
            "type": "mcp_server",
            "name": "github",
            "url": "https://api.githubcopilot.com/mcp",
            "credential": "github-production"
        }
    ]
}'

credential y headers siguen la misma regla de prioridad que la lista de entidades permitidas. Primero se aplica la credencial y headers se combina en la parte superior, por lo que un encabezado explícito gana si ambos establecen la misma clave:

{
    "type": "mcp_server",
    "name": "jira",
    "url": "https://jira.atlassian.com/mcp",
    "credential": "jira-oauth",
    "headers": {
        "X-Atlassian-Workspace": "my-workspace-id"
    }
}

Para mover un secreto fuera de headers intercalado y hacia una credencial, almacénalo con POST /credentials y reemplaza la entrada de autorización en headers por credential. Mantén los demás encabezados donde están.

Usa credenciales como variables de entorno

Algunas bibliotecas cliente leen los secretos del entorno del proceso en lugar de aceptarlos como encabezados de solicitud. Los clientes en modo de socket y de sondeo largo son el caso común.

Vincula una credencial environment_variable a un nombre de variable en environment.env:

Python

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    input="Run the sync script and check notifications.",
    environment={
        "type": "remote",
        "env": {
            "NODE_ENV": "production",
            "SLACK_BOT_TOKEN": {"credential": "slack-bot-token"},
        },
    },
)

JavaScript

const interaction = await client.interactions.create({
    agent: "antigravity-preview-09-2026",
    input: "Run the sync script and check notifications.",
    environment: {
        type: "remote",
        env: {
            NODE_ENV: "production",
            SLACK_BOT_TOKEN: { credential: "slack-bot-token" },
        },
    },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "agent": "antigravity-preview-09-2026",
    "input": "Run the sync script and check notifications.",
    "environment": {
        "type": "remote",
        "env": {
            "NODE_ENV": "production",
            "SLACK_BOT_TOKEN": { "credential": "slack-bot-token" }
        }
    }
}'

env acepta cadenas literales y referencias de credenciales de forma paralela. Se inserta una cadena literal en el contenedor como una variable de texto simple normal.

Una referencia de credencial no lo es. La variable recibe el marcador de posición __GEMINI_CRED_<credential-id>__, y el proxy intercambia el secreto real solo para las solicitudes salientes que van a un dominio en el trusted_domains de la credencial. Se rechaza cualquier solicitud a otro dominio, por lo que el secreto nunca sale del perímetro y no se envía el marcador de posición en su lugar.

Establece trusted_domains en cada credencial de environment_variable. Es el control que define el alcance de dónde se puede usar el secreto.

Cómo crear una credencial

Cada solicitud de creación necesita un type, además de los campos que requiera ese tipo.

Cuando se llama a REST directamente, todos los nombres de los campos usan snake_case. Si se envía un campo camelCase, se devuelve un 400.

Token del portador

Una credencial de token de portador solo necesita token:

Python

credential = client.credentials.create(
    id="github-production",
    type="bearer_token",
    token="ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
)

JavaScript

const credential = await client.credentials.create({
    id: "github-production",
    type: "bearer_token",
    token: "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "github-production",
    "type": "bearer_token",
    "token": "ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}'

La respuesta solo devuelve metadatos, nunca el token:

{
  "id": "github-production",
  "type": "bearer_token",
  "status": "active",
  "create_time": "2026-07-15T10:00:00.000000000Z",
  "update_time": "2026-07-15T10:00:00.000000000Z"
}

De forma predeterminada, el proxy envía Authorization: Bearer <token>. Anula header_name y prefix para segmentar un servicio que espera otra cosa:

Python

credential = client.credentials.create(
    id="my-api-key",
    type="bearer_token",
    token="key_xxxxxxxxxxxx",
    header_name="x-goog-api-key",
    prefix="",
)

JavaScript

const credential = await client.credentials.create({
    id: "my-api-key",
    type: "bearer_token",
    token: "key_xxxxxxxxxxxx",
    header_name: "x-goog-api-key",
    prefix: "",
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "my-api-key",
    "type": "bearer_token",
    "token": "key_xxxxxxxxxxxx",
    "header_name": "x-goog-api-key",
    "prefix": ""
}'

Esta configuración genera el encabezado x-goog-api-key: key_xxxxxxxxxxxx.

En la siguiente tabla, se muestra cómo se combinan header_name y prefix:

Configuración	Encabezado insertado
`{"token": "ghp_xxx"}`	`Authorization: Bearer ghp_xxx`
`{"token": "sk_live_xxx"}`	`Authorization: Bearer sk_live_xxx`
`{"token": "key_xxx", "header_name": "x-goog-api-key", "prefix": ""}`	`x-goog-api-key: key_xxx`
`{"token": "mytoken", "header_name": "X-API-Token", "prefix": ""}`	`X-API-Token: mytoken`

OAuth2

Una credencial de OAuth2 requiere client_id, client_secret, refresh_token y token_url. El campo scopes es opcional:

Python

credential = client.credentials.create(
    id="jira-oauth",
    type="oauth2",
    client_id="my-client-id",
    client_secret="my-client-secret",
    token_url="https://auth.atlassian.com/oauth/token",
    refresh_token="rt_xxxxxxxxxxxxxxxxxxxx",
    scopes=["read:jira-work", "write:jira-work"],
)

JavaScript

const credential = await client.credentials.create({
    id: "jira-oauth",
    type: "oauth2",
    client_id: "my-client-id",
    client_secret: "my-client-secret",
    token_url: "https://auth.atlassian.com/oauth/token",
    refresh_token: "rt_xxxxxxxxxxxxxxxxxxxx",
    scopes: ["read:jira-work", "write:jira-work"],
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "jira-oauth",
    "type": "oauth2",
    "client_id": "my-client-id",
    "client_secret": "my-client-secret",
    "token_url": "https://auth.atlassian.com/oauth/token",
    "refresh_token": "rt_xxxxxxxxxxxxxxxxxxxx",
    "scopes": ["read:jira-work", "write:jira-work"]
}'

Cuando se crea una credencial de OAuth2, se realiza un intercambio de tokens en vivo con token_url para confirmar que la configuración funciona. La credencial solo se almacena si el proveedor devuelve una respuesta de token exitosa que contiene un access_token. Se aceptan respuestas con formato JSON y form-urlencoded.

Esto significa que necesitas un token de actualización válido y no vencido en el momento de la creación. Si el proveedor rechaza el intercambio, se te devolverá el error:

{
  "error": {
    "message": "OAuth token validation failed with HTTP 403: {\"error\":\"unauthorized_client\",\"error_description\":\"refresh_token is invalid\"}",
    "code": "invalid_request"
  }
}

Una vez almacenado, el proxy actualiza los tokens de acceso a medida que vencen. Si el proveedor rota los tokens de actualización y devuelve uno nuevo durante una actualización, el token nuevo reemplaza automáticamente al almacenado.

Variable de entorno

Una credencial de environment_variable requiere value y injection_location:

Python

credential = client.credentials.create(
    id="slack-bot-token",
    type="environment_variable",
    value="xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx",
    trusted_domains=["*.slack.com", "slack.com"],
    injection_location="header",
)

JavaScript

const credential = await client.credentials.create({
    id: "slack-bot-token",
    type: "environment_variable",
    value: "xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx",
    trusted_domains: ["*.slack.com", "slack.com"],
    injection_location: "header",
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/credentials" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "id": "slack-bot-token",
    "type": "environment_variable",
    "value": "xoxb-xxxxxxxxxxxx-xxxxxxxxxxxx",
    "trusted_domains": ["*.slack.com", "slack.com"],
    "injection_location": "header"
}'

El campo injection_location le indica al proxy en qué parte de la solicitud saliente debe sustituir el secreto. Acepta header, query o body, ya sea como una sola cadena o como un array cuando un servicio necesita más de uno:

"injection_location": ["header", "query"]

La sustitución solo se realiza en las ubicaciones que enumeras. Se rechaza una solicitud que incluye el marcador de posición en cualquier otro lugar en lugar de enviarla.

Para vincular la credencial a un nombre de variable, consulta Usa credenciales como variables de entorno.

IDs generados

El campo id es opcional. Si lo omites, el servicio generará un UUID:

{
  "id": "9e545973-4330-49bb-9a44-930cea9fbe3c",
  "type": "bearer_token",
  "status": "active",
  "create_time": "2026-07-15T10:00:00.000000000Z",
  "update_time": "2026-07-15T10:00:00.000000000Z"
}

Proporciona tu propio ID cuando quieras una referencia estable y legible para usar en todas las interacciones. Dado que el ID aparece en la ruta de acceso al recurso, se prefieren los caracteres alfanuméricos en minúscula con guiones o guiones bajos.

Enumera las credenciales

Enumera las credenciales que pertenecen a tu proyecto. Usa parámetros de paginación para controlar el tamaño del lote de respuestas.

Python

response = client.credentials.list(page_size=10)
for credential in response.credentials:
    print(f"Credential ID: {credential.id}, Type: {credential.type}")

JavaScript

const response = await client.credentials.list({ page_size: 10 });
for (const credential of response.credentials) {
    console.log(`Credential ID: ${credential.id}, Type: ${credential.type}`);
}

REST

curl -X GET "https://generativelanguage.googleapis.com/v1beta/credentials?page_size=10" \
-H "x-goog-api-key: $GEMINI_API_KEY"

La respuesta solo contiene metadatos:

{
  "credentials": [
    {
      "id": "github-production",
      "type": "bearer_token",
      "status": "active",
      "create_time": "2026-07-15T10:00:00.000000000Z",
      "update_time": "2026-07-15T10:00:00.000000000Z"
    },
    {
      "id": "jira-oauth",
      "type": "oauth2",
      "status": "active",
      "create_time": "2026-07-15T10:05:00.000000000Z",
      "update_time": "2026-07-15T10:05:00.000000000Z"
    }
  ],
  "next_page_token": "Cj...5aE="
}

Pasa next_page_token como page_token para recuperar la página siguiente. El campo se omite cuando no hay más resultados.

Parámetro	Tipo	Descripción
`page_size`	integer	Es la cantidad máxima de credenciales por página.
`page_token`	string	Es el token del campo `next_page_token` de una respuesta anterior.

Obtén una credencial

Recupera los metadatos de una credencial específica por su ID.

Python

credential = client.credentials.get(id="github-production")
print(f"Credential ID: {credential.id}, Status: {credential.status}")

JavaScript

const credential = await client.credentials.get("github-production");
console.log(`Credential ID: ${credential.id}, Status: ${credential.status}`);

REST

curl -X GET "https://generativelanguage.googleapis.com/v1beta/credentials/github-production" \
-H "x-goog-api-key: $GEMINI_API_KEY"

El resultado es similar al siguiente:

{
  "id": "github-production",
  "type": "bearer_token",
  "status": "active",
  "create_time": "2026-07-15T10:00:00.000000000Z",
  "update_time": "2026-08-01T14:30:00.000000000Z"
}

Si se solicita una credencial que no existe, se devuelve 404:

{
  "error": {
    "message": "Result not found.; GetCredential call failed",
    "code": "not_found"
  }
}

Rota una credencial

Reemplaza un secreto sin modificar ninguna regla de la lista de entidades permitidas, definición de herramienta o variable de entorno que lo haga referencia. La rotación se aplica en la próxima resolución del proxy.

La solicitud debe incluir type, además de los campos que deseas cambiar. Los campos que omitas conservarán sus valores actuales.

Rota un token de portador:

Python

credential = client.credentials.update(
    id="github-production",
    type="bearer_token",
    token="ghp_new_xxxxxxxxxxxxxxxxxxxx",
)

JavaScript

const credential = await client.credentials.update("github-production", {
    type: "bearer_token",
    token: "ghp_new_xxxxxxxxxxxxxxxxxxxx",
});

REST

curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/credentials/github-production" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "type": "bearer_token",
    "token": "ghp_new_xxxxxxxxxxxxxxxxxxxx"
}'

Rota un token de actualización de OAuth2:

Python

credential = client.credentials.update(
    id="jira-oauth",
    type="oauth2",
    refresh_token="rt_new_xxxxxxxxxxxxxxxxxxxx",
)

JavaScript

const credential = await client.credentials.update("jira-oauth", {
    type: "oauth2",
    refresh_token: "rt_new_xxxxxxxxxxxxxxxxxxxx",
});

REST

curl -X PATCH "https://generativelanguage.googleapis.com/v1beta/credentials/jira-oauth" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "type": "oauth2",
    "refresh_token": "rt_new_xxxxxxxxxxxxxxxxxxxx"
}'

La respuesta refleja el nuevo update_time:

{
  "id": "jira-oauth",
  "type": "oauth2",
  "status": "active",
  "create_time": "2026-07-15T10:05:00.000000000Z",
  "update_time": "2026-08-01T14:30:00.000000000Z"
}

El type de una credencial se fija en el momento de la creación. Para cambiarla, borra la credencial y crea una nueva.

Cómo borrar una credencial

Borra una credencial y su secreto almacenado cuando ya no sean necesarios.

Python

client.credentials.delete(id="github-production")

JavaScript

await client.credentials.delete("github-production");

REST

curl -X DELETE "https://generativelanguage.googleapis.com/v1beta/credentials/github-production" \
-H "x-goog-api-key: $GEMINI_API_KEY"

Una eliminación correcta muestra un objeto vacío:

{}

Cualquier regla de lista de entidades permitidas, herramienta o variable de entorno que aún haga referencia al ID no se resolverá, por lo que primero debes actualizar esos elementos.

Referencia de campo

Campos comunes a todas las credenciales:

Campo	Tipo	Obligatorio	Descripción
`id`	string	No	Es un identificador único. Se genera como un UUID cuando se omite.
`type`	string	Sí	Es uno de los siguientes: `bearer_token`, `oauth2` o `environment_variable`.
`status`	string	Solo lectura	Es el estado actual de la credencial.
`create_time`	string	Solo lectura	Es la marca de tiempo de creación en formato RFC 3339.
`update_time`	string	Solo lectura	Es la marca de tiempo RFC 3339 de la última actualización.

Campos para bearer_token:

Campo	Tipo	Obligatorio	Descripción
`token`	string	Sí	Solo escritura. Es el valor del token.
`header_name`	string	No	Es el encabezado que se insertará. La configuración predeterminada es `Authorization`.
`prefix`	string	No	Es el prefijo del valor. La configuración predeterminada es `Bearer`. Se establece en `""` para que no haya ninguna.

Campos para oauth2:

Campo	Tipo	Obligatorio	Descripción
`client_id`	string	Sí	ID de cliente de OAuth2.
`client_secret`	string	Sí	Solo escritura. Es el secreto del cliente de OAuth2.
`refresh_token`	string	Sí	Solo escritura. Es el token de actualización que se usa para obtener tokens de acceso.
`token_url`	string	Sí	Es el extremo del token del proveedor.
`scopes`	array	No	Son los permisos de OAuth que se solicitarán.

Campos para environment_variable:

Campo	Tipo	Obligatorio	Descripción
`value`	string	Sí	Solo escritura. Es el valor del secreto.
`injection_location`	string o arreglo	Sí	Dónde se sustituirá el secreto. Uno o más de `header`, `query`, `body`.
`trusted_domains`	array	No	Son los patrones de dominio autorizados para la sustitución.

Errores

Los errores devuelven un objeto JSON con un message y un code:

{
  "error": {
    "message": "Credential 'github-production' already exists.; CreateCredential call failed",
    "code": "aborted"
  }
}

Estado de HTTP	`code`	Causa
400	`invalid_request`	Falta un campo obligatorio, hay un campo desconocido, no se admite `type` o falló la validación de OAuth2.
404	`not_found`	No hay ninguna credencial con ese ID.
409	`aborted`	Ya existe una credencial con ese ID.

Los campos desconocidos se rechazan en lugar de ignorarse, y el error nombra el campo:

{
  "error": {
    "message": "Unknown parameter 'headerName'. Did you mean 'header_name'?",
    "code": "invalid_request"
  }
}

¿Qué sigue?

Entornos: Obtén información sobre cómo los agentes ejecutan código y conservan archivos.
Descripción general de los agentes: Obtén información sobre los conceptos básicos de los agentes administrados.
Cómo crear agentes personalizados: Define tus propios agentes con AGENTS.md y SKILL.md.

Credenciales en agentes administrados

Python

JavaScript

REST

Python

JavaScript

REST

Tipos de credenciales

Usa credenciales en la lista de entidades permitidas de la red

Python

JavaScript

REST

Cómo combinar credential y transform

Usa credenciales con servidores de MCP

Python

JavaScript

REST

Usa credenciales como variables de entorno

Python

JavaScript

REST

Cómo crear una credencial

Token del portador

Python

JavaScript

REST

Python

JavaScript

REST

OAuth2

Python

JavaScript

REST

Variable de entorno

Python

JavaScript

REST

IDs generados

Enumera las credenciales

Python

JavaScript

REST

Obtén una credencial

Python

JavaScript

REST

Rota una credencial

Python

JavaScript

REST

Python

JavaScript

REST

Cómo borrar una credencial

Python

JavaScript

REST

Referencia de campo

Errores

¿Qué sigue?

Cómo combinar `credential` y `transform`