Let an AI Agent Publish to Xiaohongshu, Douyin and More

TL;DR: PublishPort lets an AI agent publish to social platforms by running open-source publishing CLIs on your own machine, through your real logged-in browser session. The AI sends the command; your computer runs it. That keeps posts coming from a trusted residential environment instead of a data center that platforms flag.

You can ask an AI to write a Xiaohongshu post, a Douyin caption, and an X thread in thirty seconds. Getting that content actually posted is where it falls apart. Most “AI auto-posting” setups run on a cloud server, log in from a server IP, and lose the account within days. The writing was never the hard part. The publishing was.

PublishPort takes the opposite approach. The AI stays wherever it lives. The publishing runs on the one computer the platforms already trust: yours.

Why “AI auto-posting” keeps breaking

Two things block the obvious version of this.

First, most consumer platforms have no open publishing API, or a heavily gated one. Xiaohongshu, Douyin, and most short-video apps simply do not hand you a “post on my behalf” endpoint. The login and the publish flow live inside the app and the browser.

Second, platforms do not judge your intent. They judge signals. A cloud server emits a recognizable set: a data-center IP shared by thousands of bots, a fresh browser with a thin fingerprint, a login that appears from a new region on every restart, and machine-timed bursts with no human idle pattern. Each one is a small flag. Together they read as automation, and the account gets throttled or locked.

This is why the “just give the AI an API key” idea rarely survives contact with a real platform. There usually is no key, and the environment gives the bot away.

The PublishPort model: the AI is the adapter

PublishPort does not build its own integration for every platform. The platform logins, publishing, and search all come from upstream open-source CLIs, mainly opencli, which already do this well. PublishPort adds two thin things on top: a desktop client that wraps those CLIs in a GUI, and a relay that lets an online AI drive them on your machine.

The AI only ever sees two tools:

list_capabilities() returns a one-line menu of what your machine can do, for example “opencli xiaohongshu: search, creator data, publish”.
local_bash(cmd) runs a command locally.

When the AI wants to use a tool, it reads that tool’s --help and drives it directly. There is no per-platform adapter to maintain, no manifest engine, no schema to normalize. The AI is the adapter, and --help is the schema. Adding a new platform is one line in the capability list; the upstream project does the integration work.

If you want to try this on your own accounts, download the PublishPort client and connect a platform first. The rest of this guide assumes you have it running.

How it fits into your AI workflow

Connecting an AI takes four steps:

Install the client and sign in. Open the PublishPort desktop app and log in to your account.
Log in to each platform through your real browser. The client opens your actual browser for the login, so the session is genuine. A connected account turns green.
Start the local executor. This connects your machine to the relay so commands can reach it.
Paste the MCP endpoint into your AI client. PublishPort speaks the Model Context Protocol, so it plugs into Claude or any MCP-capable client. From then on, the AI can call list_capabilities() and local_bash() against your machine.

The endpoint is the gate. Anyone who holds it can run commands on your computer through the relay, so treat it like a password.

A concrete example

Say you want one idea turned into posts across three platforms. A working session looks like this:

The AI calls list_capabilities() and sees Xiaohongshu, Douyin, and X are connected.
It runs opencli xiaohongshu --help to learn the publish flags, then drafts a version tuned for that audience and publishes it.
It repeats for Douyin and X, adjusting the copy for each platform’s format and length instead of pasting the same text everywhere.

You stayed in the chat. The posting happened on your laptop, in sessions the platforms already trust. Nothing logged in from a strange IP, because nothing logged in anywhere new.

The boundaries (read this before you scale)

Local publishing changes the math on risk control, but it is not a magic shield, and pretending otherwise would be dishonest.

It does not guarantee you will never be limited or banned. Platform rules change, and posting behavior itself is a signal. Spammy frequency from a real machine is still spammy.
The MCP endpoint is the only gate. If it leaks, someone else can drive your machine. Rotate it if you suspect exposure.
Some platforms, like WeChat’s ecosystem, restrict what any tool can do. Know what is and is not possible before you build a workflow around it.

Used at a sane cadence, with content meant for actual readers, a trusted local session is the sturdiest place to publish from. For the reasoning on why this beats cloud automation, see why local-environment publishing beats cloud automation.

FAQ

Do I need an API key for each platform?

No. PublishPort drives the platforms through your logged-in browser session using upstream CLIs, so it works on platforms that have no public publishing API at all. You log in once per platform through your real browser.

Is my account safer than with a cloud posting bot?

In most cases yes, because the activity comes from your residential IP and a real, established browser session rather than a data-center IP and a fresh fingerprint. It is safer, not risk-free. Frequency and content still matter.

Which platforms are supported?

Through the upstream open-source CLIs, the client can reach 65+ platforms, including Xiaohongshu, Douyin, Weibo, Zhihu, Bilibili, X, and Reddit, plus article platforms like Juejin and CSDN. The list grows as the upstream projects add adapters.

What is the MCP endpoint and why does it matter?

It is the address your AI client uses to reach your machine through the relay. It is also the only access gate, so anyone holding it can run commands on your computer. Keep it private and rotate it if it leaks.

PublishPort is a thin layer of glue over open-source publishing CLIs. We do not build the platform integrations ourselves; we wrap them in a client and a relay so an AI can use them from your machine. If something here is wrong or out of date, the docs are the source of truth.