Taisly Agent

by taisly

350 downloads

Not rated

GitHub

About

Taisly Agent is an MCP server, CLI, SDK, and agent skill for publishing short-form videos to TikTok, Instagram Reels, YouTube Shorts, X, and Facebook through Taisly. It helps AI agents and automation workflows validate connected social accounts, create video posts, and check publ

Details

Author: taisly
Downloads: 350
Categories: Marketing, Other, AI, Automation

- JSON‑first CLI and SDK for agentic video publishing.
- Stdio MCP server with nine tools (e.g., taisly_posts_create).
- Built‑in agent skill enforcing a safe workflow: auth → platforms → validate → confirm → create → status.
- Cross‑platform posting to TikTok, Instagram Reels, YouTube Shorts, X, and Facebook.
- Supports scheduling, local file validation, and JSON payload files.
- Works with Codex, Claude Code, Cursor, OpenClaw, and custom agents.

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Taisly Agent

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

From the repository

Install globally with npm install -g @taisly/agent, then run npx @taisly/agent help or start the stdio MCP server with npx @taisly/agent mcp. Authentication requires setting the TAISLY_API_KEY environment variable. Use CLI commands like taisly auth:status, taisly platforms:list, taisly posts:validate, and taisly posts:create. MCP clients can connect via the taisly tool with the @taisly/agent mcp command.

`taisly_agent_setup_start`

Start browser-based Taisly authentication for an AI agent. Returns a loginUrl that the user must open and approve before checkin.

`taisly_agent_checkin`

Finish setup after the user approves the loginUrl in the browser. Saves the local Taisly agent credential for later CLI and MCP calls.

`taisly_auth_status`

Check whether the Taisly API key is valid and count connected social accounts.

`taisly_platforms_list`

List connected TikTok, Instagram, YouTube, X, Facebook, and other social accounts available to this API key.

`taisly_platform_schema`

Get local posting constraints for a destination platform before validating or creating a post.

`taisly_platform_connect_start`

Start browser-based connection for a social account. Returns a connectUrl that the user must open and approve in the browser.

`taisly_platform_connect_check`

Check whether a social account connection started by taisly_platform_connect_start has appeared in Taisly.

`taisly_posts_validate`

Validate a local video path, destination platform IDs, caption, and optional schedule before publishing.

`taisly_posts_create`

Publish or schedule a video post through Taisly after the user explicitly confirms the media, destinations, caption, and schedule.

`taisly_posts_status`

Fetch recent-history status for a Taisly post by historyId.

`taisly_posts_list`

List recent Taisly post history for status checks and audits.

`taisly_reposts_list`

List configured repost automations for connected social accounts.

`taisly_reposts_create`

Create a repost automation from one connected account to one or more destination accounts.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "taisly agent": {
            "taisly": {
                "command": "npx",
                "args": [
                    "-y",
                    "@taisly/agent",
                    "mcp"
                ],
                "env": {
                    "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
                }
            }
        }
    }
}

McpServers

{
    "taisly": {
        "command": "npx",
        "args": [
            "-y",
            "@taisly/agent",
            "mcp"
        ],
        "env": {
            "TAISLY_API_KEY": "<YOUR_TAISLY_API_KEY>"
        }
    }
}

Publish short-form videos to TikTok, Instagram Reels, YouTube Shorts, X, and Facebook from AI agents through the official Taisly MCP server.

Free AI-first social media posting for short-form video. Taisly Agent Kit is a JSON-first SDK, CLI, Agent Skill, and MCP server that lets AI agents, developer tools, and automation workflows publish videos to TikTok, Instagram Reels, YouTube Shorts, X, Facebook, and other connected social platforms through Taisly.

Use it when your agent can create content, write captions, or prepare a campaign, but still needs a reliable video publishing API to put that content online. The package is free to install and designed to get an agent from idea to published video without building every platform integration yourself.

Read this guide in:English,Español,Deutsch,Français,Português,ไทย,中文,Bahasa Indonesia,Русский,Nederlands,한국어,日本語,العربية,Türkçe,Polski.

- Build AI agent social media posting into Codex, Claude Code, Cursor, OpenClaw, and custom automation tools.
- Automate video publishing from one local file to multiple connected social accounts.
- Give agents a safe JSON workflow: discover accounts, validate payloads, create posts, and check status.
- Add TikTok API posting automation, Instagram Reels automation, YouTube Shorts publishing, and cross-platform social media automation without building every platform integration yourself.
- Start free, then upgrade only when the publishing workflow grows.

Taisly handles the connected accounts and posting execution. Your agent handles planning, caption writing, campaign logic, or workflow orchestration.

- Install the package for free.
- Create or connect a Taisly account from your AI agent.
- Let the agent authenticate, connect social accounts, validate videos, and publish through a JSON-first workflow.
- Upgrade later when you need higher-volume publishing, larger account sets, or automatic repost workflows.

No credit card is required to get started. Paid plans are for teams and workflows that need more scale.

This package includes theTaisly Social Media Posting SkillinSKILL.md. Use it with Claude Code, Codex, Cursor, OpenClaw, and other agents when you want the agent to understand the safe posting workflow before it touches live social accounts.

auth -> platforms -> validate -> confirm -> create -> status

The skill tells agents to discover connected accounts, validate the post, ask for explicit user confirmation, create the post, and save the returnedhistoryIdfor status checks.

This package includes a Codex plugin manifest in.codex-plugin/plugin.json. The plugin points Codex to the canonicalSKILL.mdfile and the official remote MCP server:

Use the plugin when you want Codex to discover both the posting workflow instructions and the Taisly MCP tools from one package. The rootSKILL.mdis the single source of truth for the agent workflow.

For local development inside this repository:

The easiest flow is to let your AI agent open the browser login for you. Use any short agent slug, for exampleclaude-code,codex,cursor,windsurf,openclaw,hermes-agent,cline, oraider.

Help me set up Taisly Agent Kit. 1. Install the CLI: npm i -g @taisly/agent 2. Run taisly setup --agent <agent-slug> and send me the login URL so I can finish authentication. 3. Wait for me to finish login in the browser. 4. Run taisly checkin --agent <agent-slug>. 5. Tell me if Taisly is connected and ready. If not, tell me what failed. If you cannot install or run the Taisly CLI in this environment, stop and tell me to open Taisly Settings instead.

The setup command stores a local Taisly agent credential, so later CLI and MCP commands can run without manually copying an API key.

Manual fallback: create an API key in Taisly Settings, then set:

export TAISLY_API_KEY="taisly_..."

Advanced: by default, the browser setup stores the local credential in~/.taisly/config.json. Most users should not change this. SetTAISLY_CONFIG_HOME=/path/to/dironly for CI, tests, or isolated agent profiles that need a separate credential store.

List the connected social accounts available to the API key:

taisly auth:status taisly platforms:list

Connect a social account from an AI-agent flow:

taisly platforms:connect:start --platform instagram # Open the returned connectUrl and finish authorization in the browser. taisly platforms:connect:check --platform instagram taisly platforms:list

Supported connect slugs:instagram,tiktok,youtube,x,facebook.

Validate a local video before publishing:

taisly posts:validate \ --video ./launch.mp4 \ --platforms platform_id_1,platform_id_2 \ --description "Launch day"

taisly posts:create \ --video ./launch.mp4 \ --platforms platform_id_1,platform_id_2 \ --description "Launch day"

taisly posts:create \ --video ./launch.mp4 \ --platforms platform_id_1,platform_id_2 \ --description "Launch day" \ --scheduled "2026-06-14T09:00:00+07:00"

taisly posts:status --id <historyId>

Every command prints JSON so agents can parse results without scraping terminal text.

Taisly is published in the official MCP Registry as:

Display name:Taisly Social Media Posting

The remote MCP server uses streamable HTTP and OAuth. Remote MCP tools can publish only from publicvideoUrlvalues because they cannot read local files from your machine.

codex mcp add taisly --url https://app.taisly.com/mcp codex mcp login taisly

claude mcp add --transport http taisly https://app.taisly.com/mcp

Then ask Claude Code to verify the connection. If OAuth is needed, Claude Code can guide the browser login from the session. You can also authenticate explicitly withclaude mcp login taislyif you want to complete the OAuth flow from the shell before using tools.

Taisly Agent Kit also includes a local stdio MCP server in the same package. Use local MCP when your agent needs to read local video files:

{ "mcpServers": { "taisly": { "command": "npx", "args": ["@taisly/agent", "mcp"] } } }

If you already use a manual API key, you can still passTAISLY_API_KEYin the MCP serverenvblock.

codex mcp add taisly -- npx @taisly/agent mcp

claude mcp add taisly -- npx @taisly/agent mcp

…

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

taisly_agent_setup_start

taisly_agent_checkin

taisly_auth_status

taisly_platforms_list

taisly_platform_schema

taisly_platform_connect_start

taisly_platform_connect_check

taisly_posts_validate

taisly_posts_create

taisly_posts_status

taisly_posts_list

taisly_reposts_list

taisly_reposts_create

Claude Desktop / Cursor

McpServers

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Context 7

Reactive Resume

`taisly_agent_setup_start`

`taisly_agent_checkin`

`taisly_auth_status`

`taisly_platforms_list`

`taisly_platform_schema`

`taisly_platform_connect_start`

`taisly_platform_connect_check`

`taisly_posts_validate`

`taisly_posts_create`

`taisly_posts_status`

`taisly_posts_list`

`taisly_reposts_list`

`taisly_reposts_create`