> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nekt.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Composio as a data source
> Bring data from Composio to Nekt.
Composio is a tool-calling platform for AI agents. It gives agents authenticated access to
hundreds of third-party applications — Slack, GitHub, Gmail, Notion and others — by handling
the OAuth connections, exposing each application's actions as callable tools, and forwarding
the applications' events as triggers.
This connector brings two kinds of data to Nekt: the **catalog** of what Composio can do
(toolkits, tools, and trigger types) and the **activity** of your own project (authentication
configurations, connected accounts, active triggers, MCP servers, and the full execution and
trigger event logs).
## 1. Add your Composio access
1. In the [Sources](https://app.nekt.ai/sources) tab, click on the "Add source" button located on the top right of your screen. Then, select the Composio option from the list of connectors.
2. Click **Next** and you'll be prompted to add your access.
* **API Key**: your Composio project API key. In the [Composio dashboard](https://app.composio.dev), go to **Settings → Project Settings** and copy the key from the **API Keys** section. See the [official documentation](https://docs.composio.dev/reference/v3/authentication) for details.
* **Initial sync date**: the starting point for the two log streams. Execution and trigger log entries older than this date are not synced. Leave it empty to bring the full history Composio still retains.
* **Toolkit slugs** (advanced): an optional list of toolkit slugs, such as `slack` or `github`. When filled, the `tools` and `trigger_types` catalog streams are narrowed to those toolkits. Leave it empty to sync the full Composio catalog, which spans every available toolkit and is considerably larger.
3. Click **Next**.
A Composio API key is scoped to a single **project**. To bring data from more than one project, create one Nekt source per project.
## 2. Select your Composio streams
1. The next step is letting us know which streams you want to bring. You can select entire groups of streams or only a subset of them.
> Tip: The stream can be found more easily by typing its name.
2. Click **Next**.
## 3. Configure your Composio data streams
1. Customize how you want your data to appear in your catalog. Select a name for each table (which will contain the fetched data) and the type of sync.
* **Layer**: companies in the Growth plan can choose in which [layer](https://docs.nekt.com/get-started/core-concepts/catalog-layers) the tables with the extracted data will be placed.
* **Table name**: we suggest a name, but feel free to customize it. You have the option to add a **prefix** to all tables at once and make this process faster!
* **Sync Type**: depending on the data you are bringing to the lake, you can choose between INCREMENTAL and FULL\_TABLE. Read more about Sync Types [here](https://docs.nekt.com/get-started/core-concepts/types-of-sync).
2. Click **Next**.
## 4. Configure your Composio data source
1. Describe your data source for easy identification within your organization. You can inform things like what data it brings, to which team it belongs, etc.
2. To define your [Trigger](https://docs.nekt.com/runs/scheduling-and-triggers), consider how often you want data to be extracted from this source. This decision usually depends on how frequently you need the new table data updated (every day, once a week, or only at specific times).
3. Optionally, you can define some additional settings (if available).
* Configure Delta Log Retention and determine for how long we should store old states of this table as it gets updated. Read more about this resource [here](https://docs.nekt.com/get-started/core-concepts/resource-control).
* Determine when to execute an **Additional [Full Sync](https://docs.nekt.com/get-started/core-concepts/types-of-sync#additional-full-sync)**. This will complement the incremental data extractions, ensuring that your data is completely synchronized with your source every once in a while.
### Check your new source!
1. Click **Next** to finalize the setup. Once completed, you'll receive confirmation that your new source is set up!
2. You can view your new source on the [Sources](https://app.nekt.ai/sources) page. Now, for you to be able to see it on your [Catalog](https://app.nekt.ai/catalog), you have to wait for the pipeline to run. You can now monitor it on the [Sources](https://app.nekt.ai/sources) page to see its execution and completion. If needed, manually trigger the pipeline by clicking on the refresh icon. Once executed, your new table will appear in the Catalog section.
> If you encounter any issues, reach out to us via Slack, and we'll gladly assist you!
## Available streams
| Stream | Slug | Sync | Description |
| --------------------- | ----------------------- | ----------- | ---------------------------------------------------------------------------- |
| Toolkits | `toolkits` | Full table | Applications and services Composio can connect to. |
| Toolkit Categories | `toolkit_categories` | Full table | Categories used to group toolkits. |
| Tools | `tools` | Full table | Individual actions an agent can call, with their input and output schemas. |
| Trigger Types | `trigger_types` | Full table | Event types toolkits can emit, with their configuration and payload schemas. |
| Auth Configs | `auth_configs` | Full table | How your project authenticates against each toolkit. |
| Connected Accounts | `connected_accounts` | Full table | End-user connections between your project and an external service. |
| Trigger Instances | `trigger_instances` | Full table | Triggers your project has enabled on its connected accounts. |
| MCP Servers | `mcp_servers` | Full table | MCP servers your project exposes to AI assistants. |
| Action Execution Logs | `action_execution_logs` | Incremental | Every tool execution, with its status and duration. |
| Trigger Logs | `trigger_logs` | Incremental | Every trigger event Composio received and dispatched. |
Composio embeds live credentials in some API responses — the OAuth tokens of each connected account, the client secrets of your authentication configurations, and the shareable access URL of each MCP server. This connector removes all of them before writing to your Catalog, so no Composio credential ever reaches your Lakehouse.
## Streams and fields
The applications and services Composio can connect to. Deprecated toolkits are included so
rows never silently disappear from your Catalog.
**Key Fields:**
* `slug` - URL-friendly unique identifier of the toolkit, used to reference it everywhere else
* `name` - Human-readable name of the toolkit
* `type` - Toolkit provenance: `native` for Composio-managed toolkits, `custom` for one registered by your project
* `toolkit_id` - Legacy internal identifier, useful for cross-referencing older Composio data
**Description and Branding:**
* `description` - What the toolkit is for and which functionality it exposes
* `logo` - Image URL of the toolkit's branding
* `app_url` - Link to the toolkit's main application or service website
* `auth_guide_url` - Guide with authentication setup instructions
**Authentication:**
* `auth_schemes` - Authentication methods supported by the toolkit, such as `OAUTH2` or `API_KEY`
* `composio_managed_auth_schemes` - Methods for which Composio provides the OAuth application, so your project does not need its own credentials
* `no_auth` - Whether the toolkit can be used without any authentication
**Content and Metadata:**
* `categories` - Categories the toolkit belongs to, as a JSON array of objects with `id` and `name`
* `tools_count` - Number of tools available in the toolkit
* `triggers_count` - Number of trigger types available in the toolkit
* `version` - Version of the toolkit definition
* `created_at` - When the toolkit was added to the Composio catalog
* `updated_at` - When the toolkit definition was last modified
The categories used to group toolkits in the Composio catalog.
**Key Fields:**
* `id` - URL-friendly unique identifier of the category, used to filter toolkits
* `name` - Display name of the category
The individual actions an agent can call through Composio. The full catalog spans every
toolkit and is large — use the **Toolkit slugs** setting to narrow it down.
**Key Fields:**
* `slug` - Unique identifier of the tool, used when executing it
* `name` - Human-readable display name
* `description` - Explanation of the tool's functionality, as presented to the calling agent
* `human_description` - Human-friendly description, when the toolkit provides one
**Parent Toolkit:**
* `toolkit_slug` - Identifier of the toolkit that provides the tool
* `toolkit_name` - Name of that toolkit
* `toolkit_logo` - URL of that toolkit's logo image
**Schemas:**
* `input_parameters` - JSON Schema of the tool's input arguments, as a JSON string
* `output_parameters` - JSON Schema of the tool's return value, as a JSON string
**Access and Versioning:**
* `no_auth` - Whether the tool can be executed without a connected account
* `scopes` - Flat list of OAuth scopes the tool requires
* `scope_requirements` - Structured scope requirements, as a JSON object. Null means the tool is legacy and only exposes the flat scopes list
* `tags` - Tags used to categorize and filter the tool
* `version` - Current version of the tool definition
* `available_versions` - All versions of the tool that can be pinned
* `is_deprecated` - Whether the tool is deprecated and may be removed in the future
The event types toolkits can emit into Composio.
**Key Fields:**
* `slug` - Unique identifier of the trigger type
* `name` - Human-readable name of the trigger
* `description` - What the trigger does and when it fires
* `instructions` - Step-by-step instructions to set it up
* `type` - Trigger mechanism: `webhook` (event-based) or `poll` (scheduled check)
**Parent Toolkit:**
* `toolkit_slug` - Identifier of the toolkit that provides the trigger
* `toolkit_logo` - URL of that toolkit's logo image
**Schemas and Setup:**
* `config` - JSON Schema of the configuration required to set up the trigger, as a JSON string
* `payload` - JSON Schema of the payload delivered when the trigger fires, as a JSON string
* `requires_webhook_endpoint_setup` - Whether a Composio-issued webhook URL must first be registered with the upstream provider
* `version` - Version of the trigger type definition
How your project authenticates against each toolkit. Credential material is never synced.
**Key Fields:**
* `id` - Unique identifier of the authentication configuration
* `uuid` - Legacy UUID, kept for backward compatibility
* `name` - Display name of the configuration
* `type` - Whether it is a Composio `default` or a `custom` configuration created by your project
* `status` - Current status: `ENABLED` or `DISABLED`
**Toolkit and Scheme:**
* `toolkit_slug` - Toolkit the configuration authenticates against
* `toolkit_logo` - URL of that toolkit's logo image
* `auth_scheme` - Scheme used, such as `OAUTH2`, `API_KEY` or `BEARER_TOKEN`
* `is_composio_managed` - Whether Composio supplies the OAuth application, instead of your project bringing its own client credentials
**Usage and Access:**
* `no_of_connections` - Number of active connected accounts using the configuration
* `tools_for_connected_account_creation` - Tools used to derive the minimum OAuth scopes required
* `tools_available_for_execution` - Tools that accounts connected through this configuration are allowed to execute
* `expected_input_fields` - Fields the end user must fill in when connecting an account, as a JSON array
* `is_enabled_for_tool_router` - Whether the configuration is exposed to the Composio tool router
* `proxy_url` - URL of the authentication proxy, when one is used
**Audit:**
* `created_by` - Identifier of the user who created the configuration
* `created_at` - When the configuration was created
* `last_updated_at` - When the configuration was last modified
The end-user connections between your project and an external service — one row per user
per application. Access and refresh tokens are never synced.
**Key Fields:**
* `id` - Unique identifier of the connected account
* `toolkit_slug` - Toolkit the account is connected to
* `user_id` - End user the connection belongs to. Composio is phasing this field out of the API response, so it may come back empty
* `alias` - User-defined alias for the connected account
* `word_id` - Short, token-friendly identifier used to disambiguate multiple accounts of the same toolkit, such as `gmail_red-castle`
**Status:**
* `status` - Connection status: `INITIALIZING`, `INITIATED`, `ACTIVE`, `FAILED`, `EXPIRED`, `INACTIVE` or `REVOKED`
* `status_reason` - Explanation of the last status change, when the API provides one
* `is_disabled` - Whether the connection has been disabled
* `test_request_endpoint` - Endpoint Composio calls to verify the connection still works
**Authentication Configuration:**
* `auth_scheme` - Authentication scheme of the connection itself
* `auth_config_id` - Identifier of the configuration used to create the connection
* `auth_config_auth_scheme` - Authentication scheme of that configuration
* `auth_config_is_composio_managed` - Whether that configuration is managed by Composio
* `auth_config_is_disabled` - Whether that configuration is disabled
**Sharing:**
* `account_type` - Sharing model: `PRIVATE` (usable only by its owner) or `SHARED`
* `acl_config_for_shared` - Access control rules for shared connections, as a JSON object
**Audit:**
* `created_at` - When the connection was created
* `updated_at` - When the connection was last modified
The triggers your project has enabled on its connected accounts. Disabled instances are
included.
**Key Fields:**
* `id` - Unique identifier of the trigger instance
* `uuid` - Legacy UUID of the trigger instance
* `trigger_name` - Name of the trigger type this instance runs
* `version` - Version of the trigger instance definition
**Association:**
* `connected_account_id` - Connected account the trigger listens on
* `connected_account_uuid` - Legacy UUID of that connected account
* `user_id` - End user the trigger belongs to
**Configuration:**
* `trigger_config` - Configuration applied to the instance, as a JSON string
* `trigger_data` - Additional data attached to the instance
**Audit:**
* `created_at` - When the instance was created
* `updated_at` - When the instance was last modified
* `disabled_at` - When the instance was disabled, when applicable
The MCP servers your project exposes so AI assistants can reach its toolkits.
**Key Fields:**
* `id` - Unique identifier of the MCP server
* `name` - User-defined name of the server
* `server_instance_count` - Number of active user instances connected to the server
* `managed_auth_via_composio` - Whether authentication for the server is managed by Composio
**Scope:**
* `toolkits` - Toolkit slugs the server exposes
* `allowed_tools` - Tool slugs the server is allowed to execute
* `auth_config_ids` - Authentication configurations the server can use
* `toolkit_icons` - Mapping of each toolkit slug to its icon URL, as a JSON object
**Client Setup:**
* `command_cursor` - Command line instruction to connect the Cursor client
* `command_claude` - Command line instruction to connect the Claude client
* `command_windsurf` - Command line instruction to connect the Windsurf client
**Audit:**
* `created_at` - When the server was created
* `updated_at` - When the server configuration was last modified
Every tool execution Composio ran for your project — the stream to use for measuring agent
activity, success rates, and latency. Synced incrementally on `created_at`.
**Key Fields:**
* `id` - Unique identifier of the execution log entry
* `created_at` - Timestamp of the execution, used as the incremental replication key
* `status` - Outcome of the execution: `success` or `failed`
* `execution_time` - Duration of the execution in milliseconds
**What Ran:**
* `action_key` - Slug of the tool that was executed
* `app_key` - Slug of the toolkit the tool belongs to
* `app_name` - Display name of that toolkit
* `app_icon` - URL of that toolkit's icon image
**On Whose Behalf:**
* `connected_account_id` - Connected account used for the execution
* `entity_id` - End user on whose behalf the tool ran
**Result:**
* `minimal_response` - Truncated response body recorded for the execution
* `metadata` - Additional execution metadata, as a JSON object
Every trigger event Composio received from an upstream provider and dispatched to your
project. Synced incrementally on `created_at`.
**Key Fields:**
* `id` - Unique identifier of the trigger log entry
* `created_at` - When the event was received, used as the incremental replication key
* `updated_at` - When the log entry was last updated
* `status` - Outcome recorded for the trigger event
* `type` - Log entity type: `trigger` or `action`
**What Fired:**
* `trigger_name` - Name of the trigger type that fired
* `trigger_id` - Identifier of the trigger instance that fired
* `trigger_nano_id` - Nano ID of that trigger instance
* `app_name` - Name of the toolkit that emitted the event
* `provider` - Upstream provider that delivered the event
**Association:**
* `connection_id` - Connected account the event came from
* `client_id` - Composio client that owns the event
* `entity_id` - End user the event belongs to
**Payload:**
* `meta` - Full event detail, including the provider and client payloads, as a JSON object
## Notes and limitations
* **Log streams use internal endpoints.** `action_execution_logs` and `trigger_logs` read the endpoints that back the Log pages of the Composio dashboard. Composio publishes them in its public API document and accepts the regular project API key on them, but does not document their fields in the API reference, so they may change with less notice than the rest of the API.
* **Log history depends on your Composio plan.** The connector can only bring what Composio still retains for your project.
* **Organization-level data is not covered.** Endpoints such as the project list require a separate organization API key, which this connector does not use.
* **Rate limits.** Composio allows between 2,000 and 10,000 requests per minute depending on your plan. The connector throttles itself well below the lowest tier and retries rate-limited requests with exponential backoff, so a sync never competes with your own agents for quota.