1
---
2
-title: CLI
3
-description: Install and use the Composio CLI to search tools, execute actions, connect accounts, listen to triggers, run scripts, proxy API calls, and manage local CLI state.
4
-keywords: [cli, command line, terminal, toolkits, tools, authentication, triggers, generate types]
2
+title: Composio CLI
3
+description: Use the Composio CLI inside Claude Code for knowledge work, debugging, and developer workflows.
4
+keywords: [cli, claude code, command line, terminal, composio for you, knowledge work, dev commands]
5
---
6
7
-The Composio CLI connects AI agents to 1000+ external apps from the terminal. Use it to discover tools, execute known tool slugs, connect accounts, stream trigger events, call raw APIs through connected accounts, and script multi-step workflows.
7
+The Composio CLI is primarily the command-line surface for [Composio for You](https://composio.dev/for-you). It is meant to be installed in your terminal and used from inside **Claude Code**, so Claude can connect apps, execute tools, inspect schemas, call authenticated APIs, and debug Composio projects while it works with you.
8
9
-The default workflow is:
9
+Use the CLI directly when you want to give Claude Code a reliable local tool surface instead of copying API keys, schemas, and one-off scripts into chat.
10
11
-1. If you know the tool slug, start with `composio execute`.
12
-2. If you do not know the slug, use `composio search`.
13
-3. If the inputs are unclear, use `composio execute --get-schema` or `--dry-run`.
14
-4. If execution says the toolkit is not connected, run `composio link <toolkit>` and retry.
15
-5. Use `composio run` for scripts, `composio listen` for temporary trigger subscriptions, and `composio proxy` for raw authenticated API requests.
16
-
17
-## Installation
11
+## Install
12
13
```bash
14
curl -fsSL https://composio.dev/install | bash
21
-```
22
-
23
-Check the installed version and upgrade when needed:
24
-
25
-```bash
26
-composio --version
27
-composio upgrade
28
-```
29
-
30
-Set up shell integration after installing or moving the binary:
31
-
32
-```bash
33
-composio install --completions
34
-```
35
-
36
-## Help modes
37
-
38
-Use `--help` on the root command or any subcommand. The root help supports `simple`, `default`, and `full` modes.
39
-
40
-```bash
41
-composio --help
42
-composio --help full
43
-composio execute --help full
44
-composio dev --help full
45
-```
46
-
47
-<Callout type="info">
48
-`composio help` is not a subcommand. Use `composio --help` or `composio <command> --help`.
49
-</Callout>
50
-
51
-## Login and workspace context
52
-
53
-For a normal human-owned account, start with browser login:
54
-
55
-```bash
15
composio login
57
-composio whoami
16
```
17
60
-Useful login options:
18
+Then open Claude Code in the project where you want to work. `composio login` installs the `composio-cli` skill for Claude Code by default. To install the skill manually:
19
20
```bash
63
-# Print a login URL/session and exit without waiting
64
-composio login --no-wait
65
-
66
-# Complete login with the key from a no-wait session
67
-composio login --key "session_key"
68
-
69
-# Login non-interactively with a user API key and organization
70
-composio login --user-api-key "uak_..." --org "org_or_name"
71
-
72
-# Skip the organization picker and use the session default
73
-composio login -y
21
+composio --install-skill composio-cli claude
22
```
23
76
-Manage your default organization context:
24
+Check your local state:
25
26
```bash
79
-composio orgs list
80
-composio orgs switch --org-id "org_xxx"
81
-```
82
-
83
-Log out when you want to clear local auth state:
84
-
85
-```bash
86
-composio logout
27
+composio whoami
28
+composio --version
29
+composio upgrade
30
```
31
89
-## Sign up as an agent
90
-
91
-Agents can create and reuse a Composio identity without a human signing up first. The CLI wraps the agent signup APIs documented in [Signing up as an agent](/docs/signing-up-as-an-agent).
32
+## 1. Using Composio CLI for knowledge work
33
93
-```bash
94
-# Sign up as an agent and log the CLI in when credentials are ready
95
-composio signup
34
+This is the recommended way to use Composio from inside Claude Code. The CLI can execute tools for you, connect accounts, script workflows, call authenticated APIs, and inspect trigger events without you wiring a custom integration first.
35
97
-# Start signup and exit without waiting for credentials
98
-composio signup --no-wait
36
+### 1.1 Search, connect, and execute tools
37
100
-# Create or verify the agent identity without logging the CLI in
101
-composio signup --no-login
102
-
103
-# Force a new agent identity even if one already exists locally
104
-composio signup --force
105
-```
106
-
107
-You can also manage agent identity through the `agent` namespace:
38
+Use this flow when Claude needs to act in one of your connected apps:
39
40
```bash
110
-composio agent signup
111
-composio agent login "composio_agent_key_..."
112
-composio agent whoami
113
-composio agent inbox --limit 20
114
-composio agent claim human@example.com
115
-```
116
-
117
-Agent identity is stored separately from the normal CLI login flow, so a background agent can bootstrap itself and later hand the organization to a human admin.
118
-
119
-## Search for tools
41
+# Find the right tool
42
+composio search "summarize my unread gmail"
43
121
-Use `composio search` when you do not know the tool slug. It accepts one or more semantic queries and returns JSON by default.
44
+# Inspect the required input schema
45
+composio execute GMAIL_FETCH_EMAILS --get-schema
46
123
-```bash
124
-composio search "send an email"
125
-composio search "send an email" "create github issue"
126
-composio search "my emails" "my github issues" --toolkits gmail,github
127
-composio search "list calendar events" --toolkits google_calendar --limit 5
128
-```
129
-
130
-Use `--human` for readable terminal output:
47
+# Connect the app if needed
48
+composio link gmail
49
132
-```bash
133
-composio search "create a github issue" --human
50
+# Execute the tool
51
+composio execute GMAIL_FETCH_EMAILS \
52
+ -d '{ query: "is:unread newer_than:1d", max_results: 10 }'
53
```
54
136
-Once you have a slug, switch back to `composio execute`.
137
-
138
-## Execute tools
55
+Useful commands:
56
140
-`composio execute` runs a tool by slug. It validates inputs against the cached schema and checks the required connected account before running the remote action.
141
-
142
-```bash
143
-composio execute GITHUB_CREATE_ISSUE \
144
- -d '{ owner: "acme", repo: "app", title: "Bug report", body: "Steps to reproduce..." }'
145
-```
57
+| Command | Use it for |
58
+|---------|------------|
59
+| `composio search` | Find relevant tools by natural language |
60
+| `composio execute` | Execute a known tool slug |
61
+| `composio link` | Connect an app account |
62
+| `composio proxy` | Call provider APIs with Composio-managed auth |
63
147
-The `-d` / `--data` flag accepts JSON, JS-style object literals, files, or stdin:
64
+Use `composio proxy` when Claude already knows the provider API endpoint and wants Composio to inject auth from your connected account:
65
66
```bash
150
-composio execute GITHUB_CREATE_ISSUE -d '{ owner: "acme", repo: "app", title: "Bug" }'
151
-composio execute GITHUB_CREATE_ISSUE -d @issue.json
152
-cat issue.json | composio execute GITHUB_CREATE_ISSUE -d -
67
+composio proxy https://gmail.googleapis.com/gmail/v1/users/me/profile --toolkit gmail
68
```
69
155
-Inspect the schema or preview a call without executing it:
70
+### 1.2 Run scripts and sub-agents
71
157
-```bash
158
-composio execute GITHUB_CREATE_ISSUE --get-schema
159
-composio execute GITHUB_CREATE_ISSUE --dry-run \
160
- -d '{ owner: "acme", repo: "app", title: "Bug" }'
161
-```
72
+Use `composio run` when Claude needs a multi-step workflow, loops, parallel fan-out, data transformation, or LLM-assisted summarization. It runs inline TS/JS or a file with `execute()`, `search()`, `proxy()`, `experimental_subAgent()`, `result.prompt()`, and `z` injected.
73
163
-Use the validation escape hatches only when you know what you are doing:
74
+Run a single scripted workflow:
75
76
```bash
166
-composio execute GITHUB_CREATE_ISSUE --skip-connection-check -d @issue.json
167
-composio execute GITHUB_CREATE_ISSUE --skip-tool-params-check -d @issue.json
168
-composio execute GITHUB_CREATE_ISSUE --skip-checks -d @issue.json
77
+composio run '
78
+const messages = await execute("GMAIL_FETCH_EMAILS", {
79
+ query: "is:unread newer_than:1d",
80
+ max_results: 10,
81
+});
82
+console.log(messages);
83
+'
84
```
85
171
-Upload a local file when the tool exposes exactly one uploadable file input:
86
+Fan out across multiple tools:
87
88
```bash
174
-composio execute SLACK_UPLOAD_OR_CREATE_A_FILE_IN_SLACK \
175
- --file ./image.png \
176
- -d '{ channels: "C123" }'
89
+composio run '
90
+const [emails, issues, events] = await Promise.all([
91
+ execute("GMAIL_FETCH_EMAILS", { max_results: 5 }),
92
+ execute("GITHUB_LIST_REPOSITORY_ISSUES", { owner: "composiohq", repo: "composio", state: "open" }),
93
+ execute("GOOGLECALENDAR_FIND_EVENT", { calendar_id: "primary" }),
94
+]);
95
+console.log({ emails: emails.data, issues: issues.data, events: events.data });
96
+'
97
```
98
179
-Run independent tool calls concurrently with `-p` / `--parallel`:
99
+Ask a sub-agent to summarize tool output and return structured data:
100
101
```bash
182
-composio execute -p \
183
- GMAIL_SEND_EMAIL -d '{ recipient_email: "a@b.com", subject: "Hi", body: "Hello" }' \
184
- GITHUB_CREATE_ISSUE -d '{ owner: "acme", repo: "app", title: "Bug" }'
185
-```
186
-
187
-If output is too large for the terminal, the CLI stores it in the session artifact directory. Use `composio artifacts cwd` to find that directory.
102
+composio run --logs-off '
103
+const [emails, issues] = await Promise.all([
104
+ execute("GMAIL_FETCH_EMAILS", { max_results: 5 }),
105
+ execute("GITHUB_LIST_REPOSITORY_ISSUES", { owner: "composiohq", repo: "composio", state: "open" }),
106
+]);
107
189
-## Connect and manage accounts
108
+const brief = await experimental_subAgent(
109
+ `Create a morning brief from these emails and issues.\n\n${emails.prompt()}\n\n${issues.prompt()}`,
110
+ {
111
+ schema: z.object({
112
+ brief: z.string(),
113
+ urgentEmails: z.array(z.string()),
114
+ urgentIssues: z.array(z.string()),
115
+ }),
116
+ }
117
+);
118
191
-`composio link` connects an external account for a toolkit such as GitHub, Gmail, Slack, or Google Calendar.
192
-
193
-```bash
194
-composio link github
195
-composio link gmail --alias work
119
+console.log(brief.structuredOutput);
120
+'
121
```
122
198
-Useful link options:
123
+Run a checked-in script:
124
125
```bash
201
-# Print link info and exit without waiting for browser authorization
202
-composio link github --no-wait
203
-
204
-# List existing connected accounts for a toolkit
205
-composio link github --list
126
+composio run --file ./workflow.ts -- --repo composiohq/composio
127
```
128
208
-The normal flow is to try `execute` first. If the CLI reports that no account is connected, run `link` and retry the same `execute` command.
209
-
210
-Inspect or remove connected accounts with `connections`:
211
-
212
-```bash
213
-composio connections list
214
-composio connections list --toolkit github
215
-composio connections remove github
216
-composio connections remove work
217
-```
129
+### 1.3 Listen to trigger events
130
219
-Aliases for duplicate toolkit accounts require the `multi_account` experimental feature:
131
+Use trigger listening when Claude needs to wait for new events, inspect incoming payloads, or forward events while debugging. In the current CLI, trigger event streaming is exposed through the developer namespace:
132
133
```bash
222
-composio config experimental multi_account on
223
-```
134
+# Compact table view for matching events
135
+composio dev listen --toolkits gmail --table
136
225
-## Inspect tools and triggers
137
+# Raw JSON payloads, then stop after five events
138
+composio dev listen --trigger-slug GMAIL_NEW_GMAIL_MESSAGE --json --max-events 5
139
227
-Use `tools` and `triggers` when you already know the toolkit or slug and want a compact summary.
140
+# Forward each matching event to a local or hosted webhook
141
+composio dev listen --toolkits github --forward https://example.com/webhook
142
229
-```bash
230
-# Tools
231
-composio tools list gmail
232
-composio tools list gmail --query "send" --tags important --limit 20
233
-composio tools info GMAIL_SEND_EMAIL
234
-
235
-# Trigger types
236
-composio triggers list gmail
237
-composio triggers list gmail --limit 20
238
-composio triggers info GMAIL_NEW_GMAIL_MESSAGE
143
+# Append matching events to a local file for Claude to inspect
144
+composio dev listen --toolkits slack --out ./events.jsonl
145
```
146
241
-For execution arguments, `composio execute <slug> --get-schema` is usually the most direct schema view.
147
+Filter by toolkit, trigger slug, trigger ID, connected account ID, or user ID when you want Claude to focus on one event source.
148
243
-## Listen to trigger events
149
+## 2. Using Composio CLI to build on Composio
150
245
-`composio listen` creates a temporary subscription for consumer-project trigger events and writes each payload into the session artifact folder. Use it when an agent needs to consume new emails, Slack messages, or other events during a run.
151
+Use the CLI while building on the Composio developer platform. These commands help initialize local project context, create auth configs, manage connected accounts, test tool execution, inspect logs, and debug trigger flows.
152
247
-```bash
248
-composio listen GMAIL_NEW_GMAIL_MESSAGE
249
-composio listen GMAIL_NEW_GMAIL_MESSAGE --timeout 5m
250
-composio listen GMAIL_NEW_GMAIL_MESSAGE --max-events 5
251
-```
252
-
253
-Pass trigger creation params as JSON, JS-style object literals, `@file`, or stdin:
153
+### Initialize project context
154
155
```bash
256
-composio listen SLACK_RECEIVE_MESSAGE \
257
- -p '{ trigger_config: { channel: "C123" } }' \
258
- --max-events 10
259
-
260
-composio listen GMAIL_NEW_GMAIL_MESSAGE -p @trigger.json --stream
261
-```
156
+# Initialize local project context
157
+composio dev init
158
263
-Use `--stream` to also print each payload inline. You can pass a jq-like path to stream one field:
159
+# Toggle developer mode
160
+composio dev --mode on
161
+composio dev --mode off
162
265
-```bash
266
-composio listen GMAIL_NEW_GMAIL_MESSAGE --timeout 1hr --stream '.data.threadId'
163
+# Switch or inspect project scope
164
+composio dev projects list
165
+composio dev projects switch
166
```
167
269
-See where payload artifacts are stored:
168
+### Inspect toolkits and versions
169
170
```bash
272
-composio artifacts cwd
171
+composio dev toolkits list
172
+composio dev toolkits search "email"
173
+composio dev toolkits info github
174
+composio dev toolkits version github
175
```
176
275
-## Script workflows with run
276
-
277
-Use `composio run` for multi-step workflows, loops, conditionals, parallel fan-out, or LLM-assisted summarization. It runs inline TS/JS or a file with injected helpers.
278
-
279
-Injected helpers:
280
-
281
-| Helper | Description |
282
-| --- | --- |
283
-| `execute(slug, data?)` | Run a tool, like `composio execute`, and return parsed JSON |
284
-| `search(query, opts?)` | Find tools, like `composio search` |
285
-| `proxy(toolkit)` | Return a `fetch()` bound to a connected account for that toolkit |
286
-| `experimental_subAgent(prompt, opts?)` | Ask a Claude/Codex sub-agent, optionally with structured output |
287
-| `result.prompt()` | Serialize any helper result into an LLM-friendly string |
288
-| `z` | Global Zod instance for structured output schemas |
289
-
290
-Examples:
177
+### Create and inspect auth configs
178
179
```bash
293
-# Inline workflow
294
-composio run '
295
- const me = await execute("GITHUB_GET_THE_AUTHENTICATED_USER");
296
- console.log(me);
297
-'
298
-
299
-# Sequential actions across services
300
-composio run '
301
- const issue = await execute("GITHUB_CREATE_ISSUE", {
302
- owner: "acme",
303
- repo: "app",
304
- title: "Deploy v2"
305
- });
306
- await execute("SLACK_SEND_A_MESSAGE_TO_A_SLACK_CHANNEL", {
307
- channel: "eng",
308
- text: "Created: " + issue.data.html_url
309
- });
310
-'
180
+# List existing auth configs
181
+composio dev auth-configs list
182
+composio dev auth-configs list --toolkits github,gmail
183
+composio dev auth-configs info ac_xxx
184
312
-# Run a file and pass script args after --
313
-composio run --file ./workflow.ts -- --repo acme/app
314
-```
315
-
316
-Debug or preview scripts:
317
-
318
-```bash
319
-composio run --dry-run 'await execute("GMAIL_SEND_EMAIL", { recipient_email: "a@b.com" })'
320
-composio run --debug --file ./workflow.ts
321
-composio run --logs-off '/* hide experimental_subAgent streaming logs */'
185
+# Create an auth config from provider credentials
186
+composio dev auth-configs create "GitHub OAuth" \
187
+ --toolkit github \
188
+ --auth-scheme OAUTH2 \
189
+ --scopes "repo,user" \
190
+ --custom-credentials '{ "client_id": "...", "client_secret": "..." }'
191
```
192
324
-Use top-level `composio execute -p` instead when you only need a few independent tool calls and no script logic.
193
+### Manage connected accounts
194
326
-## Call raw APIs with proxy
327
-
328
-Use `composio proxy` when you already know the API endpoint and want Composio to inject auth from a connected account. Pass the full API URL and the toolkit slug.
195
+Top-level `composio link` is the fastest path for personal knowledge work. Use developer connected-account commands when you are building against project users, auth configs, and playground flows.
196
197
```bash
331
-composio proxy https://gmail.googleapis.com/gmail/v1/users/me/profile --toolkit gmail
332
-
333
-composio proxy https://gmail.googleapis.com/gmail/v1/users/me/drafts \
334
- --toolkit gmail \
335
- -X POST \
336
- -H 'content-type: application/json' \
337
- -d '{"message":{"raw":"..."}}'
198
+composio dev connected-accounts list
199
+composio dev connected-accounts list --toolkits github --user-id user_123
200
+composio dev connected-accounts list --status ACTIVE --limit 20
201
+composio dev connected-accounts info ca_xxx
202
+composio dev connected-accounts whoami ca_xxx
203
+composio dev connected-accounts link
204
```
205
340
-`-d` accepts raw text, JSON, `@file`, or `-` for stdin. Use `--skip-connection-check` only when you need to bypass the connected-account preflight.
341
-
342
-You can also use `proxy()` inside `composio run`:
206
+### Execute and inspect logs
207
208
```bash
345
-composio run '
346
- const gmail = await proxy("gmail");
347
- const profile = await gmail("https://gmail.googleapis.com/gmail/v1/users/me/profile");
348
- console.log(profile);
349
-'
350
-```
351
-
352
-## Generate type definitions
353
-
354
-Generate TypeScript or Python type stubs for selected toolkits, tools, and triggers. The current CLI requires at least one `--toolkits` value.
209
+# Execute a tool through the developer playground path
210
+composio dev playground-execute GMAIL_SEND_EMAIL \
211
+ -d '{ recipient_email: "you@example.com", subject: "Test", body: "Hello" }'
212
356
-```bash
357
-# Auto-detect TypeScript or Python from the project
358
-composio generate --toolkits github gmail
359
-
360
-# TypeScript
361
-composio generate ts --toolkits github gmail
362
-composio generate ts --toolkits github --output-dir ./src/composio-types
363
-composio generate ts --toolkits github --compact
364
-composio generate ts --toolkits github --transpiled
365
-composio generate ts --toolkits github --type-tools
366
-
367
-# Python
368
-composio generate py --toolkits github gmail
369
-composio generate py --toolkits github --output-dir ./composio_types
213
+# Inspect tool and trigger logs
214
+composio dev logs tools --toolkit gmail --limit 20
215
+composio dev logs tools log_xxx
216
+composio dev logs triggers --limit 20
217
```
218
372
-<Callout type="info">
373
-Type generation is most useful when you are using [direct tool execution](/docs/tools-direct/executing-tools). If you use sessions with meta tools, you usually do not need generated stubs.
374
-</Callout>
375
-
376
-## Local files, artifacts, and config
377
-
378
-Show where the CLI stores local data:
219
+### Work with triggers
220
221
```bash
381
-composio files
382
-composio artifacts cwd
222
+composio dev triggers list gmail
223
+composio dev triggers info GMAIL_NEW_GMAIL_MESSAGE
224
+composio dev triggers status
225
+composio dev triggers create
226
+composio dev triggers enable ti_xxx
227
+composio dev listen --trigger-slug GMAIL_NEW_GMAIL_MESSAGE --json --max-events 5
228
```
229
385
-Important locations:
230
+### Generate type definitions
231
387
-| Path | Purpose |
388
-| --- | --- |
389
-| `~/.composio/` | CLI auth, config, cached tool/toolkit definitions, trigger types, analytics ID, and per-org consumer caches |
390
-| `$TMPDIR/composio/` | Session artifacts, large outputs, downloaded files, and run/execute history |
391
-| `.composio/` | Optional per-project config such as `.env` and `project.json` |
392
-
393
-Useful path environment variables:
394
-
395
-| Variable | Description |
396
-| --- | --- |
397
-| `COMPOSIO_SESSION_DIR` | Override the session artifacts root |
398
-| `COMPOSIO_CACHE_DIR` | Override the cache directory and artifact fallback location |
399
-
400
-View or toggle experimental CLI features:
232
+For legacy direct tool execution projects, generate local TypeScript or Python types from tool schemas:
233
234
```bash
403
-composio config experimental
404
-composio config experimental listen
405
-composio config experimental multi_account on
406
-composio config experimental multi_account off
235
+composio generate
236
+composio generate ts --toolkits github,gmail
237
+composio generate py --toolkits github,gmail
238
```
239
409
-## Developer project commands
240
+Use this section when you are debugging auth configs, connected accounts, trigger delivery, or tool execution in a Composio project. For general user-facing app development, prefer the SDK/session docs first and use the CLI as a local debugging companion.
241
411
-Use the `dev` namespace when you are building an app or agent with Composio's SDK and need developer-scoped project setup, playground execution, logs, toolkits, auth configs, connected accounts, triggers, and projects.
242
+## 3. Building directly on top of the CLI
243
413
-```bash
414
-# Initialize this directory with a developer project
415
-composio dev init
244
+Building products directly on top of the CLI is **not recommended**. The CLI is in constant development and Composio does not provide CLI-level SLAs as an application runtime contract.
245
417
-# Turn developer mode on or off
418
-composio dev --mode on
419
-composio dev --mode off
246
+If you need a stable production integration, build on top of the Composio SDKs and APIs instead.
247
421
-# Execute a tool against a developer playground user
422
-composio dev playground-execute GMAIL_SEND_EMAIL \
423
- --user-id demo-user \
424
- -d '{ recipient_email: "a@b.com", subject: "Hello" }'
248
+That said, the CLI can be useful as a bootstrap or helper layer for agent-native products:
249
426
-# Inspect logs
427
-composio dev logs tools --toolkit gmail --limit 20
428
-composio dev logs tools log_xxx
429
-composio dev logs triggers --limit 20
430
-
431
-# Stream developer-project trigger events
432
-composio dev listen --toolkits gmail --table
433
-composio dev listen --trigger-slug GMAIL_NEW_GMAIL_MESSAGE --json --max-events 5
434
-composio dev listen --toolkits github --forward https://example.com/webhook
435
-```
436
-
437
-Common `dev` groups:
438
-
439
-| Group | Examples |
440
-| --- | --- |
441
-| Project | `dev init`, `dev projects list`, `dev projects switch` |
442
-| Execution | `dev playground-execute`, `dev listen`, `dev logs tools`, `dev logs triggers` |
443
-| Toolkits | `dev toolkits list`, `dev toolkits info`, `dev toolkits search`, `dev toolkits version` |
444
-| Auth configs | `dev auth-configs list`, `dev auth-configs info`, `dev auth-configs create` |
445
-| Connected accounts | `dev connected-accounts link`, `list`, `info`, `whoami` |
446
-| Triggers | `dev triggers list`, `info`, `status`, `create`, `enable`, `disable` |
250
+- Use [Signing up as an agent](/docs/signing-up-as-an-agent) when an agent needs to programmatically create or reuse a Composio identity.
251
+- Use `composio connections list` to inspect which connected accounts are available locally.
252
+- Use `composio run` or `composio proxy` for internal automations where CLI churn is acceptable.
253
448
-Disabling trigger instances is guarded. It requires `developer.destructive_actions: true` in `~/.composio/config.json` and `--dangerously-allow` on the command line.
254
+For an example of a product built around CLI-driven agent workflows, see [Houston](https://github.com/gethouston/houston).
255
450
-## Agent skill installation
256
+## Help
257
452
-The CLI can install Composio skills into supported coding agents when auto-installation fails or you want to install manually.
258
+Use `--help` on the root command or any subcommand:
259
260
```bash
455
-composio --install-skill claude
456
-composio --install-skill composio-cli codex
457
-composio --install-skill composio-cli openclaw
261
+composio --help
262
+composio --help full
263
+composio execute --help full
264
+composio run --help full
265
+composio dev --help full
266
```
459
-
460
-`composio login` installs the `composio-cli` skill for Claude Code by default. Pass `--no-skill-install` to skip it.
461
-
462
-## Command summary
463
-
464
-| Command | Use it for |
465
-| --- | --- |
466
-| `composio search` | Find tool slugs by use case |
467
-| `composio execute` | Run a known tool slug, inspect schemas, dry-run, or parallelize tool calls |
468
-| `composio link` | Connect an account for a toolkit |
469
-| `composio connections` | List or remove connected accounts |
470
-| `composio tools` | List tools for a toolkit or inspect a known tool |
471
-| `composio triggers` | List or inspect trigger types |
472
-| `composio listen` | Create temporary consumer-project trigger subscriptions |
473
-| `composio run` | Script multi-step workflows with injected helpers |
474
-| `composio proxy` | Call raw toolkit APIs with Composio-managed auth |
475
-| `composio signup` / `composio agent` | Bootstrap and manage an agent-owned Composio identity |
476
-| `composio generate` | Generate TypeScript or Python stubs for selected toolkits |
477
-| `composio dev` | Manage developer-project workflows |
478
-| `composio artifacts` / `composio files` | Inspect local artifact and config/cache paths |
479
-| `composio orgs` / `composio config` | Manage organization context and CLI config |
480
-| `composio version` / `composio upgrade` | Check and update the CLI |
481
-
482
-## Environment variables
483
-
484
-| Variable | Description |
485
-| --- | --- |
486
-| `COMPOSIO_API_KEY` | Composio project API key for API and SDK usage |
487
-| `COMPOSIO_BASE_URL` | Custom Composio API base URL |
488
-| `COMPOSIO_WEB_URL` | Custom Composio dashboard URL |
489
-| `COMPOSIO_SESSION_DIR` | Override the CLI session artifact root |
490
-| `COMPOSIO_CACHE_DIR` | Override the CLI cache directory |
491
-| `COMPOSIO_LOG_LEVEL` | Default logging level |
492
-| `COMPOSIO_DISABLE_TELEMETRY` | Set to `"true"` to disable telemetry |
493
-| `COMPOSIO_TOOLKIT_VERSION_{TOOLKIT}` | Override a toolkit version, for example `COMPOSIO_TOOLKIT_VERSION_GMAIL=20250901_00` |
494
-| `COMPOSIO_WEBHOOK_SECRET` | Signing secret for trigger webhook forwarding |
495
-| `COMPOSIO_ORG_ID` | Per-project or environment organization override |
496
-| `COMPOSIO_PROJECT_ID` | Per-project or environment project override |
497
-| `FORCE_USE_CACHE` | Force cache-first reads for generated toolkit and tool metadata |
498
-| `DEBUG_OVERRIDE_VERSION` | Override target CLI version during upgrade debugging |