O Gemini 3.8 Flash já está disponível. Faça um teste.

O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Credenciais em agentes gerenciados

As credenciais são secrets gerenciados pelo servidor que permitem que seus agentes alcancem serviços de terceiros sem que o secret entre no ambiente do agente. Você armazena uma credencial uma vez, faz referência a ela por ID, e o proxy de saída resolve e injeta a credencial no momento da solicitação.

Os valores de secret são somente para gravação. Depois de armazenados, eles nunca são retornados por nenhum endpoint. Assim, um agente comprometido não pode ler os tokens que está usando.

O principal lugar em que você usa uma credencial é a lista de permissões de rede em environment.network. Armazene o secret primeiro:

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"
}'

Em seguida, anexe-o ao domínio que ele 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": "*" }
            ]
        }
    }
}'

O agente agora faz solicitações autenticadas para api.github.com, e o token nunca existe na sandbox.

Tipos de credenciais

Cada credencial tem um type que determina quais campos ela aceita e como o proxy a aplica.

Tipo	Caso de uso	Comportamento
`bearer_token`	Tokens de acesso pessoal, tokens de bot, chaves de API estáticas	O proxy injeta o token como um cabeçalho da solicitação. Sem lógica de atualização.
`oauth2`	Apps OAuth e fluxos delegados pelo usuário	O proxy troca o token de atualização por tokens de acesso e os atualiza à medida que expiram.
`environment_variable`	SDKs do cliente que leem secrets do ambiente de processo	O ambiente do agente recebe um marcador de posição. O proxy substitui o segredo real em solicitações de saída.

Usar credenciais na lista de permissões de rede

Adicione credential a uma regra de lista de permissões, e o proxy vai autenticar todas as solicitações de saída para esse domínio. Essa é a maneira recomendada de dar a um agente acesso a uma API private, um repositório ou um bucket particular.

É possível misturar regras autenticadas e não autenticadas na mesma lista de permissões:

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" }
            ]
        }
    }
}'

Como o proxy resolve a credencial por solicitação, uma credencial oauth2 atualiza o token de acesso de maneira transparente. Uma interação de longa duração não é interrompida quando o token de acesso expira.

Como combinar `credential` e `transform`

As regras de lista de permissões também aceitam um objeto transform inline que define cabeçalhos diretamente na regra. Os dois mecanismos são aplicados pelo proxy de saída no fio. Portanto, em ambos os casos, o valor do cabeçalho nunca existe dentro da sandbox. Os dois campos podem aparecer na mesma regra.

Configuração da regra	Comportamento
Somente `credential`	O proxy resolve a credencial e injeta o cabeçalho em todas as solicitações ao domínio.
Somente `transform`	Injeção de cabeçalho estático. Os cabeçalhos que você escreve são enviados como estão.
Ambos	A credencial é aplicada primeiro, e depois o `transform` é mesclado por cima. Um cabeçalho `transform` explícito vence se ambos definirem a mesma chave.
Nenhuma das opções	O domínio é permitido e nenhum cabeçalho é injetado.

Uma credencial é útil quando você quer armazenar um segredo uma vez e fazer referência a ele em todos os ambientes, agentes e gatilhos do seu projeto, e quando você quer que a atualização e a rotação do token de acesso sejam processadas para você. Um transform inline é adequado quando o valor pertence a uma única chamada, por exemplo, um token que você gera antes de criar a interação.

É comum combinar os dois. A credencial carrega o cabeçalho de autenticação e transform adiciona o que mais o serviço upstream espera na mesma solicitação:

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

Para mover um secret de um transform in-line para uma credencial, armazene-o com POST /credentials, substitua o cabeçalho de autenticação em transform por "credential": "<id>" e deixe o restante do objeto transform inalterado.

Usar credenciais com servidores MCP

Os servidores MCP remotos usam o mesmo campo credential. Defina-o em uma ferramenta mcp_server e o proxy vai injetar o cabeçalho de autenticação em todas as solicitações para esse 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 e headers seguem a mesma regra de precedência da lista de permissões. A credencial é aplicada primeiro, e o headers é mesclado por cima. Portanto, um cabeçalho explícito vence se ambos definirem a mesma chave:

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

Para mover um secret de headers inline para uma credencial, armazene-o com POST /credentials e substitua a entrada de autenticação em headers por credential. Mantenha os outros cabeçalhos onde estão.

Usar credenciais como variáveis de ambiente

Algumas bibliotecas de cliente leem segredos do ambiente de processo em vez de aceitá-los como cabeçalhos de solicitação. Clientes de modo de soquete e long-polling são o caso comum.

Vincule uma credencial environment_variable a um nome de variável em 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" }
        }
    }
}'

O env aceita strings literais e referências de credenciais lado a lado. Uma string literal é injetada no contêiner como uma variável de texto simples normal.

Uma referência de credencial não é. A variável recebe o marcador de posição __GEMINI_CRED_<credential-id>__, e o proxy troca o secret real apenas para solicitações de saída que vão para um domínio em trusted_domains da credencial. Uma solicitação para qualquer outro domínio é rejeitada, para que o secret nunca saia do perímetro e o marcador de posição não seja enviado no lugar dele.

Defina trusted_domains em todas as credenciais environment_variable. É o controle que define onde o secret pode ser usado.

Criar uma credencial

Cada solicitação de criação precisa de um type, além dos campos exigidos por esse tipo.

Ao chamar a REST diretamente, todos os nomes de campos usam snake_case. O envio de um campo camelCase retorna um 400.

Token do portador

Uma credencial de token do portador precisa apenas de 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"
}'

A resposta retorna apenas metadados, nunca o 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"
}

Por padrão, o proxy envia Authorization: Bearer <token>. Substitua header_name e prefix para segmentar um serviço que espera algo diferente:

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": ""
}'

Essa configuração produz o cabeçalho x-goog-api-key: key_xxxxxxxxxxxx.

A tabela a seguir mostra como header_name e prefix se combinam:

Configuração	Cabeçalho injetado
`{"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

Uma credencial OAuth2 exige client_id, client_secret, refresh_token e token_url. O campo scopes é 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"]
}'

A criação de uma credencial OAuth2 realiza uma troca de token em tempo real com token_url para confirmar que a configuração funciona. A credencial só é armazenada se o provedor retornar uma resposta de token bem-sucedida contendo um access_token. As respostas JSON e form-urlencoded são aceitas.

Isso significa que você precisa de um token de atualização válido e não expirado no momento da criação. Se o provedor rejeitar a troca, o erro será retornado para você:

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

Depois de armazenado, o proxy atualiza os tokens de acesso à medida que eles expiram. Se o provedor fizer a rotação dos tokens de atualização e retornar um novo durante uma atualização, o novo token vai substituir o armazenado automaticamente.

Variável de ambiente

Uma credencial environment_variable exige value e 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"
}'

O campo injection_location informa ao proxy onde substituir o secret na solicitação de saída. Ele aceita header, query ou body como uma única string ou como uma matriz quando um serviço precisa de mais de um:

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

A substituição acontece apenas nos locais listados. Uma solicitação que carrega o marcador de posição em qualquer outro lugar é rejeitada em vez de ser enviada.

Para vincular a credencial a um nome de variável, consulte Usar credenciais como variáveis de ambiente.

IDs gerados

O campo id é opcional. Omita-o para que o serviço gere um 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"
}

Forneça seu próprio ID quando quiser uma referência estável e legível para usar em todas as interações. Como o ID aparece no caminho do recurso, prefira alfanuméricos em minúsculas com hífens ou sublinhados.

Listar credenciais

Liste as credenciais pertencentes ao seu projeto. Use parâmetros de paginação para controlar o tamanho do lote de respostas.

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"

A resposta contém apenas metadados:

{
  "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="
}

Transmita next_page_token de volta como page_token para buscar a próxima página. O campo é omitido quando não há mais resultados.

Parâmetro	Tipo	Descrição
`page_size`	número inteiro	Número máximo de credenciais por página.
`page_token`	string	Token do `next_page_token` de uma resposta anterior.

Receber uma credencial

Recupera metadados de uma credencial específica pelo 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"

A resposta será semelhante a:

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

Solicitar uma credencial que não existe retorna 404:

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

Alternar uma credencial

Substitua um segredo sem alterar nenhuma regra da lista de permissões, definição de ferramenta ou variável de ambiente que o referencie. A rotação entra em vigor na próxima resolução de proxy.

A solicitação precisa incluir type e os campos que você quer mudar. Os campos omitidos mantêm os valores atuais.

Fazer a rotação de um token do 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"
}'

Girar um token de atualização do 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"
}'

A resposta reflete o novo 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"
}

O type de uma credencial é fixo no momento da criação. Para mudar, exclua a credencial e crie outra.

Excluir uma credencial

Exclua uma credencial e o segredo armazenado quando eles não forem mais necessários.

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"

Uma exclusão bem-sucedida retorna um objeto vazio:

{}

Qualquer regra de lista de permissões, ferramenta ou variável de ambiente que ainda faça referência ao ID não será resolvida. Portanto, atualize esses itens primeiro.

Referência de campo

Campos comuns a todas as credenciais:

Campo	Tipo	Obrigatório	Descrição
`id`	string	Não	Identificador exclusivo. Gerado como um UUID quando omitido.
`type`	string	Sim	Uma destas opções: `bearer_token`, `oauth2` e `environment_variable`.
`status`	string	Somente leitura	Status atual da credencial.
`create_time`	string	Somente leitura	Carimbo de data/hora de criação RFC 3339.
`update_time`	string	Somente leitura	Carimbo de data/hora RFC 3339 da última atualização.

Campos para bearer_token:

Campo	Tipo	Obrigatório	Descrição
`token`	string	Sim	Somente gravação. O valor do token.
`header_name`	string	Não	Cabeçalho a ser injetado. O valor padrão é `Authorization`.
`prefix`	string	Não	Prefixo do valor. O valor padrão é `Bearer`. Defina como `""` para nenhum.

Campos para oauth2:

Campo	Tipo	Obrigatório	Descrição
`client_id`	string	Sim	ID do cliente OAuth2.
`client_secret`	string	Sim	Somente gravação. Chave secreta do cliente OAuth2.
`refresh_token`	string	Sim	Somente gravação. Token de atualização usado para receber tokens de acesso.
`token_url`	string	Sim	Endpoint do token do provedor.
`scopes`	matriz	Não	Escopos do OAuth a serem solicitados.

Campos para environment_variable:

Campo	Tipo	Obrigatório	Descrição
`value`	string	Sim	Somente gravação. O valor do secret.
`injection_location`	string ou matriz	Sim	Onde substituir o secret. Um ou mais de `header`, `query`, `body`.
`trusted_domains`	matriz	Não	Padrões de domínio autorizados para substituição.

Erros

Os erros retornam um objeto JSON com um message e um code:

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

Status HTTP	`code`	Causa
400	`invalid_request`	Campo obrigatório ausente, campo desconhecido, `type` sem suporte ou falha na validação do OAuth2.
404	`not_found`	Nenhuma credencial com esse ID.
409	`aborted`	Já existe uma credencial com esse ID.

Os campos desconhecidos são rejeitados em vez de ignorados, e o erro nomeia o campo:

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

A seguir

Ambientes: saiba como os agentes executam código e mantêm arquivos.
Visão geral dos agentes: conheça os conceitos principais dos agentes gerenciados.
Como criar agentes personalizados: defina seus próprios agentes usando AGENTS.md e SKILL.md.

Credenciais em agentes gerenciados

Python

JavaScript

REST

Python

JavaScript

REST

Tipos de credenciais

Usar credenciais na lista de permissões de rede

Python

JavaScript

REST

Como combinar credential e transform

Usar credenciais com servidores MCP

Python

JavaScript

REST

Usar credenciais como variáveis de ambiente

Python

JavaScript

REST

Criar uma credencial

Token do portador

Python

JavaScript

REST

Python

JavaScript

REST

OAuth2

Python

JavaScript

REST

Variável de ambiente

Python

JavaScript

REST

IDs gerados

Listar credenciais

Python

JavaScript

REST

Receber uma credencial

Python

JavaScript

REST

Alternar uma credencial

Python

JavaScript

REST

Python

JavaScript

REST

Excluir uma credencial

Python

JavaScript

REST

Referência de campo

Erros

A seguir

Como combinar `credential` e `transform`