Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
TypeScript agentic-aiagentsaiai-agentsaiagentsdeveloper-toolsfunction-callinggpt-4javascriptjsllmllmopsmcppythonremote-mcp-serverssetypescript
docs(changelog): cover SEC-332, correct redaction semantics, add FF escape hatch
Anshu Garg7b3ff2d0ab1a
diff --git a/docs/content/changelog/04-21-26-composio-managed-credentials-masking.mdx b/docs/content/changelog/04-21-26-composio-managed-credentials-masking.mdxindex fa6334ba6..bb51d761c 100644--- a/docs/content/changelog/04-21-26-composio-managed-credentials-masking.mdx+++ b/docs/content/changelog/04-21-26-composio-managed-credentials-masking.mdx@@ -1,29 +1,32 @@----title: "Automatic Credential Masking for Composio-Managed Connections"-description: "Access and refresh tokens for connections on Composio-managed auth configs are now always masked in API responses, regardless of project-level masking. Connections on your own auth config are unchanged."-date: "2026-04-21"+title: "Credential Redaction for Composio-Managed Auth Configs and Connections"+description: "Composio-managed auth configs and their connections now redact sensitive fields in API responses. Customer-owned auth configs continue to mask secrets; previously plaintext client_secret and developer_token values are now masked as well."+date: "2026-04-22"----For connections created through a Composio-managed auth config, access tokens, refresh tokens, and the `Authorization` header are now always masked in `connected-accounts` API responses — regardless of your project's `mask_secret_keys_in_connected_account` setting.+Two related security changes are rolling out together:++1. **Connections on Composio-managed auth configs** now always redact `access_token`, `refresh_token`, and the `Authorization` header in `connected-accounts` responses — independent of your project's `mask_secret_keys_in_connected_account` flag.+2. **Auth-config GET responses** now redact (for Composio-managed) or mask (for customer-owned) every sensitive credential field — including `client_secret` and `developer_token`, which were previously returned in plaintext under some paths.++Auth-config credential redaction is **not controlled by `mask_secret_keys_in_connected_account`**. That flag only applies to runtime connected-account credentials (access tokens, refresh tokens, and the like). Auth-config credentials are developer-owned static fields — `client_id`, `client_secret`, `developer_token`, etc. — and are always redacted or masked regardless of the project flag.**Most integrations need no changes.**-- Tool execution through the SDK, Tool Router, and MCP is unchanged. Composio handles authentication server-side, so your agents never needed to read these tokens directly.-- Connections on your own auth config are unchanged. Token visibility continues to follow your project's masking setting.+- Tool execution through the SDK, Tool Router, and MCP is unchanged. Composio uses the unredacted values server-side.+- Connections on customer-owned auth configs continue to follow your project's `mask_secret_keys_in_connected_account` setting for runtime tokens.### What is a Composio-managed auth config?-When you connect a user through a toolkit's default integration — for example, Gmail or Slack without registering your own OAuth application — the connection runs through an OAuth application that Composio owns and operates on behalf of every team using that default. The access and refresh tokens the provider issues are bound to Composio's shared OAuth client.+When you connect a user through a toolkit's default integration — for example, Gmail or Slack without registering your own OAuth application — Composio uses an OAuth application it owns and shares across every team on that default. Tokens the provider issues are bound to that shared Composio-owned client.-You can identify a Composio-managed connection by the `auth_config.is_composio_managed: true` field on the connected-account resource.--### Why this change+You can identify a Composio-managed auth config or connection by `is_composio_managed: true` on the auth-config or connected-account resource.-A single OAuth application backs every team on a default integration, and the tokens we return are bound to it. If a provider throttles, restricts, or suspends that app in response to misuse of one of its tokens, the integration becomes unavailable for every team on the default at once. Masking the tokens keeps that exposure out of API responses; Composio still uses them server-side, so tool execution is unchanged.+### 1. Connected-account tokens-### Example+Access tokens, refresh tokens, and all header and query-parameter values are now replaced with the literal string `"REDACTED"` for Composio-managed connections. No prefix, no suffix — nothing that reveals the underlying value.-Before, with project masking disabled on a Composio-managed Gmail connection:+Before, with `mask_secret_keys_in_connected_account: false` on a Composio-managed Gmail connection:```json{@@ -32,6 +35,11 @@ Before, with project masking disabled on a Composio-managed Gmail connection:"access_token": "ya29.a0ARrdaM9...full token...","refresh_token": "1//04...full token..."}+ },+ "data": {+ "headers": {+ "Authorization": "Bearer ya29.a0ARrdaM9...full token..."+ }}}```@@ -42,25 +50,75 @@ After:{"state": {"val": {- "access_token": "ya29...",- "refresh_token": "1//0..."+ "access_token": "REDACTED",+ "refresh_token": "REDACTED"+ }+ },+ "data": {+ "headers": {+ "Authorization": "REDACTED"}}}```-The same applies to `data`, `params`, and `headers.Authorization` wherever these values would otherwise appear.+Connections on customer-owned auth configs are unaffected — token visibility follows your existing `mask_secret_keys_in_connected_account` setting (`xxxx...` truncation when enabled, raw passthrough when disabled).++### 2. Auth-config credentials++`GET /api/v3/auth_configs` and `GET /api/v3/auth_configs/{id}` now redact or mask every sensitive credential field.++**Composio-managed auth configs** — every field below is replaced with `"REDACTED"`:++- `client_id`, `client_secret`, `consumer_key`, `consumer_secret`, `code_verifier`+- `bot_token`, `bearer_token`, `verification_token`, `generic_id`, `developer_token`++**Customer-owned auth configs** — `client_id` and `consumer_key` still pass through in full (you own them and need them to debug OAuth flows). The following fields are now masked as `<first-4>...<last-4>`:++- `client_secret`, `consumer_secret`, `code_verifier`+- `bot_token`, `bearer_token`, `verification_token`, `generic_id`, `developer_token`++Values shorter than 8 characters collapse to `"REDACTED"` to avoid partial leaks.++**Previously returned in plaintext:**++- `client_secret` on customer-owned auth configs.+- `developer_token` (Google Ads) and other default-scheme fields (`bot_token`, `bearer_token`, `verification_token`, `generic_id`) on Composio-managed auth configs.++If you were reading these values out of the GET response, switch to storing them alongside the code that uploaded them (see the migration section below).++### Why this change++A single OAuth application backs every team on a Composio-managed default integration, and the tokens and client secrets bound to it are shared. If a provider throttles, restricts, or suspends that app in response to misuse of one of its credentials, the integration becomes unavailable for every team on the default at once. Redacting the values keeps them out of API responses; Composio still uses them server-side, so tool execution is unchanged.++For customer-owned auth configs, masking a freshly re-read `client_secret` or `developer_token` limits the blast radius of a compromised project API key without breaking your ability to identify which credential was uploaded.### Affected endpoints+Connected accounts:+- [`GET /api/v3/connected_accounts/{id}`](/reference/api-reference/connected-accounts/getConnectedAccountsByNanoid)- [`GET /api/v3/connected_accounts`](/reference/api-reference/connected-accounts/getConnectedAccounts)- [`POST /api/v3/connected_accounts`](/reference/api-reference/connected-accounts/postConnectedAccounts)+- Webhook payloads that include connection credentials++Auth configs:++- [`GET /api/v3/auth_configs/{id}`](/reference/api-reference/auth-configs/getAuthConfigsByNanoid)+- [`GET /api/v3/auth_configs`](/reference/api-reference/auth-configs/getAuthConfigs)-### If you need raw tokens+### If you need raw values-To keep reading `access_token` or `refresh_token` from API responses, connect through your own auth config. Tokens issued against an OAuth application you own are returned in full (subject to your project's masking setting).+**Connected-account tokens.** Connect through a customer-owned auth config, and optionally set `mask_secret_keys_in_connected_account: false` on your project.1. Register an OAuth application with the provider — for Gmail, start in the [Google Cloud Console](https://console.cloud.google.com/apis/credentials).2. [Create a custom auth config](/reference/api-reference/auth-configs/postAuthConfigs) using those credentials.3. Create new connections against that auth config.++**Auth-config secrets** (`client_secret`, `developer_token`, etc.). Keep these alongside the code that created the auth config — for example, in your own secret manager at upload time. The auth-config GET endpoints will only return masked or redacted values going forward.++**Temporary per-project exception.** If this change blocks an active production integration and you cannot complete the migration above immediately, contact support. We can toggle off forced redaction for Composio-managed connections on your project for a limited migration window, after which the project reverts to the default redacted behavior.++<Callout type="info">+If your integration relies on reading `access_token`, `refresh_token`, `client_secret`, or `developer_token` from Composio API responses, you will need to act. All other integrations continue to work as before.+</Callout>