# How to Deploy a Claude Skill to Composio: A Step-by-Step Guide

> Deploy a Claude skill to Composio with this step-by-step guide. Learn to create a SKILL.md file, install the Connect-Apps plugin, and authenticate using your API key for seamless tool integration.

- Repository: [Composio/awesome-claude-skills](https://github.com/composiohq/awesome-claude-skills)
- Tags: how-to-guide
- Published: 2026-07-23

---

**Deploying a Claude skill to Composio requires creating a [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) definition file, installing the Connect-Apps plugin, and authenticating with your Composio API key to enable external tool calls.**

This guide walks through the complete deployment workflow using the **ComposioHQ/awesome-claude-skills** repository. You will learn how to structure your skill, wire it to Composio's tool catalog, and load it into Claude-Code for production use.

## Understanding the Three-Layer Architecture

The Composio ecosystem organizes deployment into three distinct layers that work together to connect Claude with external APIs:

| Layer | Purpose | Location in Repository |
|------|---------|------------------------|
| **Skill definition** | Human-readable instructions ([`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md)) plus optional scripts/templates that tell Claude *what* to do | Any `<skill-name>/SKILL.md` (e.g., [[`connect/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/connect/SKILL.md)](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/connect/SKILL.md)) |
| **MCP server** (optional) | A lightweight HTTP service that exposes external APIs as *tools* that Claude can call; Composio's Rube MCP handles auth, rate-limiting, and schema discovery | [`mcp-builder/`](https://github.com/ComposioHQ/awesome-claude-skills/tree/master/mcp-builder) – see [[`mcp_best_practices.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/mcp_best_practices.md)](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/mcp-builder/reference/mcp_best_practices.md) |
| **Connect-Apps Plugin** | The glue that loads your skill into Claude, wires tool calls to Composio's catalog, and manages API key exchange | [[`connect-apps-plugin/README.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/connect-apps-plugin/README.md)](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/connect-apps-plugin/README.md) |

## Step-by-Step Deployment Guide

### Create the Skill Definition

Start by creating a dedicated folder for your skill with a mandatory [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) file:

```text
my-skill/
├─ SKILL.md          # mandatory – YAML front-matter + markdown instructions

├─ scripts/          # optional – helper scripts the skill can invoke

└─ resources/        # optional – reference files, templates, etc.

```

The [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) must begin with a YAML front-matter block containing the **name** and **description** fields. Claude reads this metadata at session start to keep token usage low, while the full markdown body loads on demand.

```markdown
---
name: my-deploy-skill
description: Deploys a web app to a chosen platform and notifies the team.
---

# My Deploy Skill

## When to Use

- Deploy a new version of a web service
- Notify a channel after a successful deployment

## Instructions

1. Call the appropriate Composio tool based on the user's target platform.
2. Pass the Git commit SHA and any build flags.
3. If the deployment succeeds, notify the team via Slack.

```

### Wire the Skill to Composio Tools

To perform external actions (e.g., "send an email" or "deploy to Vercel"), reference a **Composio tool slug** directly in your markdown instructions. For example, inside [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md):

```markdown

## Instructions

1. Use the `gmail_send_message` tool to send the email.
2. Pass the following payload:
   ```json
   {
     "to": "{{ user.email }}",
     "subject": "Your deployment report",
     "body": "{{ deployment_summary }}"
   }
   ```

```

Composio's **Rube Tool Router** looks up the proper tool definition at runtime. This pattern is demonstrated in the `connect` skill at line 86 in [[`connect/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/connect/SKILL.md)](https://github.com/ComposioHQ/awesome-claude-skills/blob/master/connect/SKILL.md), where the router maps natural language intents to specific tool calls.

If your skill requires a custom API not present in the Composio catalog, you can build a lightweight MCP server using Python or Node. The MCP best-practice guide in [`mcp-builder/reference/mcp_best_practices.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/mcp-builder/reference/mcp_best_practices.md) explains how to expose your server as a tool and support remote deployments.

### Install the Connect-Apps Plugin

The Connect-Apps plugin enables Claude to recognize your skill and access the Composio tool catalog. Install it by specifying the plugin directory when launching Claude:

```bash
claude --plugin-dir ./connect-apps-plugin

```

This plugin acts as the integration layer between Claude-Code and Composio's external services.

### Authenticate with Composio

Once the plugin is loaded, run the setup command inside Claude (or Claude-Code) to store your API credentials:

```

/connect-apps:setup

```

Claude will prompt you for a **Composio API key**. You can generate a free key at the Composio dashboard (`https://platform.composio.dev`). The key is stored in the `COMPOSIO_API_KEY` environment variable, which the `connect` skill reads on line 101 of its source code to authenticate API calls.

### Load the Skill into Claude

Copy your skill folder into Claude-Code's skill directory to make it available:

```bash
mkdir -p ~/.config/claude-code/skills/
cp -r my-skill ~/.config/claude-code/skills/

```

Verify the metadata is readable:

```bash
head ~/.config/claude-code/skills/my-skill/SKILL.md

```

Restart Claude-Code to auto-load the skill. The engine will parse the [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) and register any referenced tool slugs.

### Test the Deployment

Trigger your skill with a natural language prompt:

```

Deploy the latest version of my webapp to Vercel and notify the #engineering channel.

```

Claude will execute the following sequence:
1. Resolve the deployment intent and map it to the `vercel_create_deployment` tool via Composio
2. Perform the deployment using your stored API key
3. Post a message to Slack using `slack_post_message`

A successful execution produces a confirmation similar to the log line in [`connect/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/connect/SKILL.md): "Deploy complete – v2.4.0 live".

## Building Custom MCP Servers

When you need functionality beyond the standard Composio catalog, implement a custom MCP server. Here is a minimal Python example using Flask:

```python

# server.py – tiny Flask MCP endpoint

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.post("/tools/custom_deploy")
def custom_deploy():
    payload = request.json
    # …perform deployment logic…

    return jsonify({"status": "ok", "url": "https://example.com/app"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

```

Register this endpoint with Composio using the tool slug `custom_deploy`. The [`mcp_best_practices.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/mcp_best_practices.md) reference file details the required OpenAPI schema and deployment options for both local and cloud hosting.

## Sharing and Publishing Skills

To make your skill reusable by team members or the community:

- **Package the skill**: Zip the folder (`zip -r my-skill.zip my-skill/`) and upload it to the Claude Skills Marketplace
- **Team distribution**: Use the built-in `skill-share` skill (defined in [`skill-share/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/skill-share/SKILL.md)) to automatically post the packaged skill to a Slack channel for team visibility

## Summary

- **Skill structure**: Every deployment starts with a [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) file containing YAML front-matter (name, description) and markdown instructions
- **Tool integration**: Reference Composio tool slugs (e.g., `gmail_send_message`, `vercel_create_deployment`) in your instructions; the Rube Tool Router handles resolution at runtime
- **Plugin requirement**: Install the Connect-Apps plugin (`claude --plugin-dir ./connect-apps-plugin`) to bridge Claude and Composio
- **Authentication**: Run `/connect-apps:setup` to store your `COMPOSIO_API_KEY` environment variable
- **Installation path**: Place skills in `~/.config/claude-code/skills/` for Claude-Code to auto-load them
- **Extensibility**: Build custom MCP servers for unsupported APIs, following the patterns in [`mcp-builder/reference/mcp_best_practices.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/mcp-builder/reference/mcp_best_practices.md)

## Frequently Asked Questions

### What is the minimum file structure required to deploy a Claude skill?

You need a single [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) file inside a named folder. The file must contain YAML front-matter with `name` and `description` fields, followed by markdown instructions. Optional `scripts/` and `resources/` subdirectories can hold helper files and templates referenced by the skill.

### How does the Connect-Apps plugin work?

The Connect-Apps plugin acts as a bridge between Claude-Code and Composio's service catalog. It loads skills from the filesystem, parses their tool references, and handles API authentication using the `COMPOSIO_API_KEY` environment variable. According to the repository's [`connect-apps-plugin/README.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/connect-apps-plugin/README.md), this enables Claude to execute real-world actions like deploying code or sending messages.

### Can I use custom APIs that are not in the Composio catalog?

Yes. You can build a custom MCP (Model Context Protocol) server using Python or Node.js to expose your API as a tool. The [`mcp-builder/reference/mcp_best_practices.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/mcp-builder/reference/mcp_best_practices.md) file provides templates for local and cloud deployments. Once deployed, register the tool slug with Composio and reference it in your [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) instructions.

### Where does Claude-Code look for installed skills?

Claude-Code loads skills from the `~/.config/claude-code/skills/` directory on your local machine. Each subfolder should contain a [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) file. After copying your skill folder to this location, restart Claude-Code to load the new skill definition and make its tools available.