# Workday Adaptive Planning

```json
{
  "name": "Workday Adaptive Planning",
  "slug": "workday_adaptive_planning",
  "url": "https://composio.dev/toolkits/workday_adaptive_planning",
  "markdown_url": "https://composio.dev/toolkits/workday_adaptive_planning.md",
  "logo_url": "https://logos.composio.dev/api/workday_adaptive_planning",
  "categories": [
    "finance & accounting"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-11-14T05:33:23.946Z"
}
```

![Workday Adaptive Planning logo](https://logos.composio.dev/api/workday_adaptive_planning)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Workday Adaptive Planning MCP or direct API to query planning data, inspect model metadata, review users, and manage transactions through natural language.

## Summary

Workday Adaptive Planning is a cloud planning platform for budgets, forecasts, models, users, and transactions.
It helps finance teams manage planning data and improve forecasting accuracy.

## Categories

- finance & accounting

## Toolkit Details

- Tools: 50

## Images

- Logo: https://logos.composio.dev/api/workday_adaptive_planning

## Authentication

- **Oauth2**
  - Type: `oauth2`
  - Description: Oauth2 authentication for Workday Adaptive Planning.
  - Setup:
    - Configure Oauth2 credentials for Workday Adaptive Planning.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- List current Workday planning model metadata
- Review Workday forecast transaction records
- Check Workday planning users and permissions

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `WORKDAY_ADAPTIVE_PLANNING_CREATE_ACCOUNT` | Create Account | Create one GL, Custom, or Assumption account or account group. This administrative mutation may create unpublished model changes; proceed_with_warnings can override provider safety warnings. |
| `WORKDAY_ADAPTIVE_PLANNING_CREATE_USERS` | Create Users | Create 1 to 1000 Adaptive Planning users and return each user's creation status and immutable GUID. A password is required except for a Workday-connected instance with User Sync enabled that uses Workday SAML SSO. The operation is unavailable after Workday user synchronization. |
| `WORKDAY_ADAPTIVE_PLANNING_CUSTOM_REPORT_VALUES` | Get Custom Report Values | Run a typed matrix report over explicit X, Y, and optional filter axes and return coordinates, cells, notes, and provider messages. |
| `WORKDAY_ADAPTIVE_PLANNING_DELETE_OR_REPLACE_TRANSACTIONS` | Delete or Replace Transactions | Irreversibly delete transactions matching any supplied date or transaction-type criterion, and optionally insert replacement rows in the same operation. A start date without an end date has no upper bound; an end date without a start date has no lower bound; transaction types without dates match all dates. |
| `WORKDAY_ADAPTIVE_PLANNING_ERASE_ACTUALS` | Erase Actuals | Irreversibly erase numeric actuals for every level in the selected account family and inclusive time range. This may also delete newly empty splits and, when requested, cell notes. |
| `WORKDAY_ADAPTIVE_PLANNING_ERASE_DATA` | Erase Data | Irreversibly erase numeric plan or actuals data in an inclusive time range. Filters match only explicitly listed accounts and levels, not their descendants; Erase Data overrides access rules and level ownership. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_ACCOUNTS` | Export Accounts | Return the complete Adaptive Planning account hierarchy and account metadata, optionally filtered by sheet and enriched with account attributes and inaccessible values. A version selector adds per-account importability metadata but does not filter the hierarchy. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_ACTIVE_CURRENCIES` | Export Active Currencies | Return every currency configured in the Adaptive Planning instance. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_ATTRIBUTES` | Export Attributes | Return Adaptive Planning account, level, and dimension attributes and their recursive values, optionally restricted to selected attribute IDs. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_CALENDAR` | Export Calendar | Return all Adaptive Planning calendars with their IDs, names, codes, and default status. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_CONFIGURABLE_MODEL_DATA` | Export Configurable Model Data | Export typed, parsed CSV rows from a modeled sheet using either provider paging or the all-row streaming form. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_CUSTOMER_LOGO` | Export Customer Logo | Return the URL Workday exposes for the Adaptive Planning instance's customer logo. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_DATA` | Export Planning Data | Export account values from one Adaptive Planning version for explicit account and time filters, returning parsed CSV rows and provider messages. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_DIMENSION_FAMILIES` | Export Dimension Families | Return the account and dimension sets associated with each Adaptive Planning sheet family. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_DIMENSION_MAPPING` | Export Dimension Mapping | Return derived-dimension mapping targets and conditions for selected dimensions in a version, optionally filtered by keyword, level, or dimension values. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_DIMENSIONS` | Export Dimensions | Return custom Adaptive Planning dimensions and optionally their hierarchical values, properties, and attribute mappings. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_GROUPS` | Export User Groups | Return every global and user-owned group defined in the Adaptive Planning instance. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_INSTANCES` | Export Instances | Return the selected Adaptive Planning instance or every instance accessible to the connected user. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_LEVELS` | Export Levels | Return the accessible Adaptive Planning organization-level hierarchy, optionally filtered by version or sheet and enriched with groups, attributes, and inaccessible values. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_LOCALES` | Export Locales | Return every locale associated with the Adaptive Planning company. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_MODELED_SHEET` | Export Modeled Sheet | Return the structured definition of one modeled sheet by name, including v40 display-column account codes and configured model columns. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_PERMISSION_SETS` | Export Permission Sets | Return every Adaptive Planning permission set and its assigned internal permission codes. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_SECURITY_AUDIT` | Export Security Audit | Return Adaptive Planning security events, optionally filtered by actor and UTC time range. Without a time range Workday returns the last 24 hours; the provider retains at most 30 days of audit data. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_SHEET_DEFINITION` | Export Sheet Definition | Return the structured definition of one modeled or cube sheet by internal ID, including configured columns, dimensions, values, accounts, levels, and time settings. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_SHEETS` | Export Sheets | Return all standard, modeled, and cube sheets in the Adaptive Planning instance with their IDs, names, descriptions, and prefixes or codes. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_TIME` | Export Time | Return Adaptive Planning calendar strata and periods, optionally scoped to a version, calendar hierarchy, leaf stratum, legacy fields, or all locale translations. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_TRANSACTION_DEFINITION` | Export Transaction Definition | Return the configured Adaptive Planning transaction fields and allowed selector values needed to construct valid transaction imports. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_USERS` | Export Users | Return all users in the Adaptive Planning instance with identity, permission sets, profile, audit, lock, optional group, and subscription settings. |
| `WORKDAY_ADAPTIVE_PLANNING_EXPORT_VERSIONS` | Export Versions | Return all Adaptive Planning versions and version folders visible to the connected user, optionally including scenarios and eligible currency versions. |
| `WORKDAY_ADAPTIVE_PLANNING_IMPORT_CONFIGURABLE_MODEL_DATA` | Import Configurable Model Data | Append modeled-sheet rows, update rows matched by an import key, or update matching rows and insert new ones. This action does not run a replacement mode. |
| `WORKDAY_ADAPTIVE_PLANNING_IMPORT_CUBE_DATA` | Import Cube Data | Update existing cube facts or insert new facts in APPEND mode without scoped replacement. Imported numeric zeroes still irreversibly erase their exact cube cells. |
| `WORKDAY_ADAPTIVE_PLANNING_IMPORT_DIMENSION_MAPPING` | Import Dimension Mapping | Create or replace derived-dimension mapping criteria, or permanently delete criteria when delete=true. Derived values do not support virtual versions; duplicate conditions are rejected. |
| `WORKDAY_ADAPTIVE_PLANNING_IMPORT_GROUPS` | Import Groups | Create or update Workday/external user groups. REPLACE_ALL permanently replaces all imported groups in the instance; UPDATE changes only supplied groups. This cannot update groups created in Adaptive Planning. |
| `WORKDAY_ADAPTIVE_PLANNING_IMPORT_MODELED_SHEET` | Import Modeled Sheet | Create a modeled-sheet definition, including typed columns and API v39+ validation rules. This administrative, non-idempotent operation creates dimensions or level attributes referenced by the definition and requires Model permission. |
| `WORKDAY_ADAPTIVE_PLANNING_IMPORT_STANDARD_DATA` | Import Standard Data | Update existing standard-account facts or insert new facts in APPEND mode. This action does not delete unmatched facts. |
| `WORKDAY_ADAPTIVE_PLANNING_IMPORT_TRANSACTIONS` | Import Transactions | Insert new transaction rows without deleting existing transactions. |
| `WORKDAY_ADAPTIVE_PLANNING_PUBLISH_CHANGES` | Publish Admin Changes | Permanently publish every pending administrative change in an admin-publishing-enabled instance. This affects all batched changes, cannot select individual changes, and requires Publish Admin Changes permission. |
| `WORKDAY_ADAPTIVE_PLANNING_RECALCULATE_SHEET` | Recalculate Sheet | Recalculate Recalculate-on-Demand sheet data in a required version. Omitting sheet recalculates every on-demand sheet at the top level; a selected level includes its descendants. |
| `WORKDAY_ADAPTIVE_PLANNING_REPLACE_CONFIGURABLE_MODEL_DATA` | Replace Configurable Model Data | Irreversibly delete and replace modeled-sheet rows. REPLACE_ALL deletes every existing row on all levels, REPLACE_SECURED_COORDINATES deletes and replaces rows at matching secured coordinates, and SCOPED_REPLACE deletes and replaces rows at input levels. Choose the replacement boundary explicitly before calling. |
| `WORKDAY_ADAPTIVE_PLANNING_REPLACE_CUBE_DATA` | Replace Cube Data | Irreversibly delete all existing cube facts inside the complete supplied time, account, and level scope that are absent from the payload, then replace that scope with the supplied facts. INPUT and ALL scopes can delete substantially more data than the visible rows; verify every boundary before calling. |
| `WORKDAY_ADAPTIVE_PLANNING_REPLACE_STANDARD_DATA` | Replace Standard Data | Irreversibly delete unmatched standard-account facts inside an explicit time, account, and level scope, then replace that scope with the supplied facts. Requires the provider's replacement permissions. |
| `WORKDAY_ADAPTIVE_PLANNING_UNPUBLISHED_CHANGES_STATUS` | Get Unpublished Changes Status | Read whether admin publishing is enabled and the number of unpublished changes without publishing them. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_ACCESS_RULES` | Update Access Rules | Upload an official .xls/.xlsx access-rules template as an administrator. update replaces every rule for each listed user/group; replaceAll permanently deletes all existing access rules before installing only the spreadsheet rules. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_ACCOUNT` | Update Account | Update one existing GL, Custom, or Assumption account. This administrative mutation may create unpublished model changes; attribute value ID 0 removes that assignment and proceed_with_warnings overrides provider safety warnings. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_ACCOUNTS` | Update Accounts | Create or update GL accounts, recursive account hierarchies, and account-attribute mappings in one ordered bulk request. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_ASSOCIATIONS` | Update Ownership Associations | Update level or custom-dimension ownership. Omitting users removes all owners from that value; replaceAll permanently deletes all existing ownership entries for the association type before saving the supplied entries. Unknown users are skipped by Workday. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_ATTRIBUTES` | Update Attributes | Create or update attributes and recursive attribute-value hierarchies in one ordered bulk request. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_DIMENSIONS` | Update Dimensions | Create or update dimensions and recursive dimension-value hierarchies in one ordered bulk request. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_LEVELS` | Update Levels | Create or update levels and recursive organization hierarchies. Changing actuals ranges or re-parenting can cause Workday warnings and downstream compatibility changes. Setting delete_workflow_silently can delete workflow tasks, and setting delete_actuals_silently can delete actuals data. |
| `WORKDAY_ADAPTIVE_PLANNING_UPDATE_USERS` | Update Users | Update one or more Adaptive Planning users. If successful, Workday returns a message for each updated user. This action does not update passwords or access rules and does not function after user synchronization from Workday. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
```python
pip install composio composio_openai openai
```

```typescript
npm install @composio/core @composio/openai openai
```

#### Path 1, Step 2: Create a Composio session

Initialize Composio with the OpenAI Responses provider and create a session scoped to Workday Adaptive Planning
```python
import json
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
client = OpenAI()

session = composio.create(user_id="your-user-id", toolkits=["workday_adaptive_planning"])
tools = session.tools()
```

```typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["workday_adaptive_planning"] });
const tools = await session.tools();
```

#### Path 1, Step 3: Run Workday Adaptive Planning tools with your agent

Send a request, execute the Workday Adaptive Planning tool calls through the session, and print the final answer
```python
response = client.responses.create(
    model="gpt-5.6-sol",
    tools=tools,
    input=[{"role": "user", "content": "List the available planning model metadata in Workday Adaptive Planning"}],
)

while True:
    tool_calls = [o for o in response.output if o.type == "function_call"]
    if not tool_calls:
        break
    results = composio.provider.handle_tool_calls(response=response, session=session)
    response = client.responses.create(
        model="gpt-5.6-sol",
        tools=tools,
        previous_response_id=response.id,
        input=[
            {"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(results[i])}
            for i, call in enumerate(tool_calls)
        ],
    )

print(response.output_text)
```

```typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "List the available planning model metadata in Workday Adaptive Planning" }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and your agent framework
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
```

#### Path 2, Step 2: Create a session with MCP enabled

Create a session scoped to Workday Adaptive Planning and read its MCP URL and headers
```python
from composio import Composio

composio = Composio()
session = composio.create(user_id="your-user-id", toolkits=["workday_adaptive_planning"], mcp=True)
```

```typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["workday_adaptive_planning"],
  mcp: true,
});
```

#### Path 2, Step 3: Connect your agent to the MCP server

Pass the session's MCP URL and headers to your agent and run a Workday Adaptive Planning request
```python
import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, AssistantMessage, TextBlock

options = ClaudeAgentOptions(
    mcp_servers={
        "composio": {
            "type": "http",
            "url": session.mcp.url,
            "headers": session.mcp.headers,
        }
    },
    system_prompt="You are a helpful assistant with access to Workday Adaptive Planning tools.",
    tools=[],
    allowed_tools=["mcp__composio__*"],
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query("List the available planning model metadata in Workday Adaptive Planning")
        async for message in client.receive_response():
            if isinstance(message, AssistantMessage):
                for block in message.content:
                    if isinstance(block, TextBlock):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "List the available planning model metadata in Workday Adaptive Planning",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
```

## Why Use Composio?

### 1. AI Native Workday Adaptive Planning Integration

- Supports both Workday Adaptive Planning MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable tool execution
- Rich coverage for reading, writing, and querying your Workday Adaptive Planning data

### 2. Managed Auth

- Built-in OAuth handling with automatic token refresh and rotation
- Central place to manage, scope, and revoke Workday Adaptive Planning access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Workday Adaptive Planning
- Scoped, least privilege access to Workday Adaptive Planning resources
- Full audit trail of agent actions to support review and compliance

## Use Workday Adaptive Planning with any AI Agent Framework

Choose a framework you want to connect Workday Adaptive Planning with:

- [ChatGPT](https://composio.dev/toolkits/workday_adaptive_planning/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/workday_adaptive_planning/framework/claude-cowork)
- [Hermes](https://composio.dev/toolkits/workday_adaptive_planning/framework/hermes-agent)
- [Atomic Agent](https://composio.dev/toolkits/workday_adaptive_planning/framework/atomic-agent)

## Related Toolkits

- [Stripe](https://composio.dev/toolkits/stripe) - Stripe is a global online payments platform offering APIs for managing payments, customers, and subscriptions. Trusted by businesses for secure, efficient, and scalable payment processing worldwide.
- [44API](https://composio.dev/toolkits/44api) - 44API is an API service for validating VAT and tax identifiers and returning company details. Use it to verify business tax data and manage account IP whitelists quickly.
- [Airwallex](https://composio.dev/toolkits/airwallex) - Airwallex is a global financial platform providing business accounts, payments, payouts, FX, and cards. Built to simplify cross-border payments and streamline financial operations for businesses.
- [Aiwyn Tax MCP](https://composio.dev/toolkits/aiwyn_tax_mcp) - Aiwyn Tax MCP is a tax estimation service powered by Aiwyn's federal and state tax engine. It helps teams estimate tax outcomes without building tax calculation logic from scratch.
- [Alpaca](https://composio.dev/toolkits/alpaca) - Alpaca is a stock and crypto trading platform for commission-free trading, real-time market data, and algorithmic strategies. Use it to build brokerage apps, trading bots, and portfolio workflows with market connectivity.
- [Alpha vantage](https://composio.dev/toolkits/alpha_vantage) - Alpha Vantage is a financial data platform offering real-time and historical stock market APIs. Get instant, reliable access to equities, forex, and technical analysis data for smarter trading decisions.
- [Altoviz](https://composio.dev/toolkits/altoviz) - Altoviz is a cloud-based billing and invoicing platform for businesses. It streamlines online payments, expense tracking, and customizable invoice management.
- [Anrok](https://composio.dev/toolkits/anrok) - Anrok is a sales tax platform for software businesses that automates calculations, compliance, filings, and exemption management. It helps finance teams stay accurate and reduce the manual work of tax operations.
- [Benzinga](https://composio.dev/toolkits/benzinga) - Benzinga provides real-time financial news and data APIs for market coverage. It helps you track breaking news and actionable market insights instantly.
- [bexio](https://composio.dev/toolkits/bexio) - bexio is a Swiss business management platform for accounting, invoicing, contacts, projects, banking, expenses, and payroll. It brings core business operations into one connected workspace.
- [Bigdata.com MCP](https://composio.dev/toolkits/bigdata_com_mcp) - Bigdata.com MCP provides grounded access to financial news, transcripts, filings, and entity intelligence. Ideal for building research workflows and generating timely market insights.
- [Billsby](https://composio.dev/toolkits/billsby) - Billsby is a subscription billing platform for managing customers, subscriptions, invoices, products, plans, usage counters, add-ons, and allowances. It helps SaaS and subscription teams automate billing operations without building complex billing logic from scratch.
- [Brex](https://composio.dev/toolkits/brex) - Brex provides corporate credit cards and spend management tailored for startups and tech businesses. It helps optimize company cash flow, streamline accounting, and accelerate business growth.
- [Carta](https://composio.dev/toolkits/carta) - Carta is an equity management platform for cap tables, compensation, portfolios, and fund administration. It helps companies and investors manage ownership data and financial operations in one place.
- [Cashfree](https://composio.dev/toolkits/cashfree_payments_mcp) - Cashfree is a merchant payments platform that handles collection, payouts, subscriptions, settlements, refunds, and identity verification. Simplifies merchant money lifecycle management with unified, API-driven workflows.
- [Chaser](https://composio.dev/toolkits/chaser) - Chaser is accounts receivable automation software that sends invoice reminders and helps businesses get paid faster. It streamlines the collections process to save time and improve cash flow.
- [Clarity AI MCP](https://composio.dev/toolkits/clarity_ai_mcp) - Clarity AI MCP is an MCP toolkit for simulating SFDR 2.0 fund classifications from a fund name, ISIN, or CUSIP. Use it to tap Clarity AI disclosure data and modeling without building custom sustainability-data workflows.
- [Clientary](https://composio.dev/toolkits/clientary) - Clientary is a platform for managing clients, invoices, projects, proposals, and more. It streamlines client work and saves you serious admin time.
- [Coinbase](https://composio.dev/toolkits/coinbase) - Coinbase is a platform for buying, selling, and storing cryptocurrency. It makes exchanging and managing crypto simple and secure for everyone.
- [Coinbase Agents MCP](https://composio.dev/toolkits/coinbase_agents_mcp) - Coinbase Agents MCP is Coinbase's managed toolkit exposing accounts, portfolios, orders, fills, and market data. Use it to let authorized agents inspect holdings, execute trades, perform transfers, and handle payments.

## Frequently Asked Questions

### Do I need my own developer credentials to use Workday Adaptive Planning with Composio?

Yes, Workday Adaptive Planning requires you to configure your own OAuth credentials. Once set up, Composio handles token storage, refresh, and lifecycle management for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)