Plugging Claude Code into your TikTok pipeline: the fifteen-minute setup

Fifteen minutes. That's the time it takes, in 2026, to go from an empty terminal to a fully operational Claude Code piloting your TikTok publication pipeline via MCP. This isn't a figure of speech — I've timed the sequence three times on three different machines (two MacBook Pros and a Linux dev container). Median at 14 minutes 22 seconds, negligible standard deviation.

For anyone producing video content who hasn't yet made the MCP jump, those fifteen minutes are the best time investment of the year. Here's the exact sequence, step by step.

What you'll have at the end

By the end of this guide, Claude Code can:

• List your social accounts connected to Shortflow (YouTube, TikTok, Instagram, Facebook, Threads, LinkedIn).
• Read your local renders folder and identify new videos to publish.
• Upload an MP4 to the Shortflow media library.
• Create a scheduled multi-platform publication.
• Pull metrics from an existing publication.
• Read and modify Markdown or JSON scripts for your episodes.
• Commit modifications to a Git repo if you version your scripts.

All those operations in a single conversation, from the terminal, with no tab switching. This is precisely the configuration I run in production across eight channels for the past three months.

Step 1 — Install Claude Code (two minutes)

If you haven't installed Claude Code yet, it's done in two commands. On macOS and Linux:

# Download and install
curl -fsSL https://claude.com/install.sh | bash

# Verify
claude --version

On Windows, the executable installer lives at claude.com/code — same result, a few clicks.

Installation drops the claude binary into $HOME/.local/bin and adds an alias. The first invocation asks you to authenticate via your Anthropic account. The login happens in a browser, takes thirty seconds, and persists indefinitely on the machine.

What regularly tripped me up during my early installs: forgetting that the currently running terminal hadn't reloaded its PATH. If claude --version returns "command not found" after install, launch a fresh terminal — almost always the culprit.

Step 2 — Understand the MCP config (two minutes)

Claude Code stores its MCP configuration in a per-project local file. Run claude mcp in a working folder:

cd ~/dev/cocorico-tiktok-histoire
claude mcp list

The output should be empty for now — no server declared. The claude mcp add command adds servers, and claude mcp remove removes them. Each server is identified by a short name (your pick), an URL or launch command, and a transport (http, stdio or sse).

MCP servers are local or remote. A local server runs as a subprocess on your machine, launched by Claude at startup (useful for filesystem, local GitHub, Notion). A remote server lives on the internet and exposes an HTTP endpoint Claude calls (useful for Shortflow, Linear, Slack — any SaaS API that speaks MCP).

That material distinction has a practical consequence: local servers require their binary to be installed on your machine, remote servers require an API key in the authentication header. Neither is more powerful than the other; the two models coexist.

Step 3 — Connect the filesystem server (two minutes)

This is the simplest round-trip, and the one that produces the most immediate aha-moment. The MCP filesystem server lets Claude read and write inside a folder you designate.

Install:

claude mcp add filesystem --scope local \
  "npx @modelcontextprotocol/server-filesystem ~/dev/cocorico-tiktok-histoire"

The argument after the binary name is the allowed root folder. Claude will be able to read and modify any file under that directory, and nothing outside. It's a deliberate sandbox — not a technical limit.

Immediate test:

claude

In Claude Code, type:

List the MDX files in episodes/. Open the most recent and summarize its content in three sentences.

If everything works, Claude calls read_directory and read_file via MCP, you get the list and summary. The filesystem server is running. Five minutes in.

Step 4 — Connect the Shortflow server (three minutes)

The main step of the guide. The Shortflow MCP server exposes the multi-platform publication tools: list_accounts, prepare_upload, finalize_upload, create_publication, approve_publication, get_publication_status, get_post_metrics.

First — fetch an API key. Sign in to your Shortflow dashboard, go to Settings → API keys, create a new key. Format: sk_live_ followed by 32 characters. Copy it immediately — it's shown only once.

Second — declare the server in Claude Code:

claude mcp add shortflow https://api.shortflow.leandre.io/mcp \
  --transport http \
  --scope local \
  --header "Authorization: Bearer sk_live_your_key"

Four arguments: the name (shortflow), the URL (https://api.shortflow.leandre.io/mcp), the transport (http), and the authentication header carrying the key. The command takes two seconds, the echo confirms the server is declared.

Test:

claude

In Claude Code:

List the social accounts connected to my Shortflow workspace.

Typical response:

6 connected accounts:

- YouTube     · @yom-akakpo      · ACTIVE
- TikTok      · @whyfactory      · ACTIVE
- Instagram   · @yom.akakpo      · ACTIVE
- Facebook    · WhyFactory Page  · ACTIVE
- Threads     · @yom.akakpo      · ACTIVE
- LinkedIn    · Yom Akakpo       · ACTIVE

At this stage, Claude sees your publication infrastructure. You can close the terminal and disconnect Wi-Fi — the config persists. Seven minutes in.

Step 5 — Connect GitHub (three minutes, optional but recommended)

If you version your scripts in a Git repo (which I strongly recommend), the GitHub MCP server is a serious time saver. It lets Claude open branches, commit, create pull requests, read issues.

Install:

claude mcp add github \
  --scope local \
  --env GITHUB_TOKEN=ghp_your_token \
  "npx @modelcontextprotocol/server-github"

The GitHub token is generated in your GitHub account settings (Settings → Developer settings → Personal access tokens), with scopes repo and read:user. Recommended lifetime: 90 days, manual rotation.

Test:

In the cocorico-tiktok-histoire repo, show me the five most recent open issues.

If Claude correctly calls the GitHub API via MCP, you get the list without opening a browser. Ten minutes in.

Step 6 — The end-to-end test (three minutes)

This is the moment you validate that the servers play together. The conversation below uses the three previous servers in chain and reproduces, in miniature, a typical publication day.

Type exactly this into Claude Code:

1. Read the local script episodes/ep10-source.mdx and summarize its subject.
2. Verify that no episode already published on Shortflow covers exactly this subject (search by title and description).
3. If it's genuinely new, propose three hook variants you could use for the video opening, and explain the mechanism of each.

Claude will, in sequence:

1. Call read_file on the filesystem server, read your local script.
2. Call list_publications on the Shortflow server, filter by keywords pulled from the local script.
3. Synthesize both pieces of information and generate three calibrated hooks.

If everything works, you get a response in fifteen to twenty seconds that combines local reading, remote querying and editorial analysis. Without having written a single glue script.

This is the realization I mentioned in the intro. Once you've seen that run, going back to a pre-MCP workflow becomes impossible.

The classic mistake that costs you early on

A mistake I made and that I see repeated: declaring MCP servers in global scope (with --scope global instead of local). It's tempting because it means you configure once and all your projects inherit. It's also a security mistake.

Global scope places credentials in a file accessible from any Claude Code project you launch. If you occasionally work on shared code (an open-source repo, a client repo, anything not strictly yours), Claude can potentially use those credentials in the context of a project that isn't supposed to have access.

Practical rule: local scope by default, global scope never unless explicitly justified. You'll type the add command ten times a year instead of once — that's widely tolerable, and it spares you the risk of silent leakage.

The five-step recap

| Step | Action | Duration | |---|---|---| | 1 | Install Claude Code and authenticate | 2 min | | 2 | Understand local vs remote MCP config | 2 min | | 3 | Connect the filesystem server | 2 min | | 4 | Connect the Shortflow server | 3 min | | 5 | Connect the GitHub server (optional) | 3 min | | 6 | End-to-end test | 3 min | | Total | | 15 min |

Three minutes of buffer for the inevitable hiccups (a bad token, a non-existent folder, an env var to reload). In practice I timed it at 14 minutes 22 seconds — you'll be in the same range.

What you can try next

Once the basics are in place, three natural next moves to extend your setup:

Notion server, if you manage your editorial backlog there. Lets Claude read and write your Notion databases without manual intervention.

Linear or Jira server, if you track your channels as projects with issues and milestones. The issue tree becomes a directly queryable resource.

Custom server around your Python orchestrator. This is the advanced move. If you've written a Python script to generate your episodes (like my generate.py), wrapping its commands in an MCP server makes every pipeline operation callable from Claude. You move from "Claude reads my scripts" to "Claude generates an episode autonomously".

The custom MCP server is documented in the official protocol spec at modelcontextprotocol.io. A basic server fits in fifty lines of Python.

---

To start Shortflow without configuring the MCP server upstream, creating an account opens a seven-day free trial with MCP enabled by default and a pre-generated API key. The sequence above runs from the first connection.