How to Connect OpenClaw AI Agent to LinkedIn, Instagram, X, TikTok & 6 More Platforms Using Postpost

What Is OpenClaw and Why It Matters for Social Media

OpenClaw is the open-source autonomous AI agent that has taken the developer world by storm — with over 190,000 GitHub stars and a thriving ecosystem. Built by Peter Steinberger (formerly known as Clawdbot, then Moltbot), OpenClaw is an agentic AI that can reason, plan multi-step workflows, call external tools, and execute complex tasks autonomously.

What makes OpenClaw uniquely powerful for social media management is its mcporter skill — a built-in MCP (Model Context Protocol) server manager that lets OpenClaw connect to external services like Postpost. Once connected, you can manage your entire social media presence through natural conversation.

Imagine telling your AI agent: "Schedule a product launch announcement to LinkedIn, X, and Instagram for tomorrow at 9am" — and having it actually do it. That's what this guide will teach you to build.

Prerequisites

Before we begin, you'll need:

• OpenClaw installed and running (see docs.openclaw.ai)
• A Postpost account — sign up free (plans from $5.40/month)
• Your Postpost API key — found in Settings → API (starts with sk_)
• At least one connected social media account in Postpost

Step 1: Connect OpenClaw to Postpost via mcporter

OpenClaw uses mcporter — its built-in MCP server manager — to connect to external services. The connection takes about 60 seconds.

Option A: Add via mcporter CLI (Recommended)

From within OpenClaw, use the mcporter skill to add Postpost as a remote MCP server:

# List available tools from Postpost's MCP server
mcporter list --http-url https://mcp.postpost.dev --name postpost

# Persist the configuration so it's available across sessions
mcporter list --http-url https://mcp.postpost.dev --name postpost --persist config/mcporter.json

Or call a Postpost tool directly via URL — no config file needed:

# Call Postpost tools directly via HTTP URL
mcporter call https://mcp.postpost.dev list_connections

Option B: Add to mcporter.json Config

You can also add Postpost to your mcporter configuration file directly. mcporter reads config from ~/.mcporter/mcporter.json (global) or config/mcporter.json (project-level):

{
  "servers": {
    "postpost": {
      "url": "https://mcp.postpost.dev",
      "headers": {
        "Authorization": "Bearer sk_YOUR_API_KEY"
      }
    }
  }
}

Option C: Use Any MCP-Compatible Client

Since OpenClaw can use multiple CLI backends (including Claude Code), you can also configure Postpost in your Claude Code MCP config (.mcp.json), Cursor (.cursor/mcp.json), or any MCP client:

{
  "mcpServers": {
    "postpost": {
      "type": "http",
      "url": "https://mcp.postpost.dev",
      "headers": {
        "Authorization": "Bearer sk_YOUR_API_KEY"
      }
    }
  }
}

Once configured, OpenClaw gains access to 16 specialized tools across four categories: Posts, Platform Connections, LinkedIn Analytics, and Workspace management.

Verify the connection by asking OpenClaw:

You: "List my connected social media accounts"

OpenClaw: I'll check your Postpost connections...

Connected accounts:
• LinkedIn — John Doe (company page)
• X (Twitter) — @johndoe
• Instagram — @johndoe.official
• Threads — @johndoe.official
• TikTok — @johndoe
• Bluesky — @johndoe.bsky.social

Step 2: Post to LinkedIn

LinkedIn is the most popular platform for professional content. Here's how to post using both MCP (conversational) and REST API (programmatic) approaches.

Via MCP (Conversational)

You: "Post to my LinkedIn: Excited to share our latest product update!
We've added AI-powered scheduling that saves teams 10+ hours per week.
Check it out → postpost.dev #ProductUpdate #AI"

OpenClaw: I'll publish that to your LinkedIn now...

✓ Posted to LinkedIn (John Doe - company page)
  Post ID: pg_abc123
  Status: published
  URL: https://linkedin.com/feed/update/urn:li:share:7123456789

Via REST API (Programmatic)

// Node.js / TypeScript
const response = await fetch('https://api.postpost.dev/v1/posts', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    content: `Excited to share our latest product update!
We've added AI-powered scheduling that saves teams 10+ hours per week.
Check it out → postpost.dev #ProductUpdate #AI`,
    platforms: ['linkedin-connection-id'],
    status: 'published',
  }),
});

const post = await response.json();
console.log('Published:', post.data.id);

# Python
import requests

response = requests.post(
    'https://api.postpost.dev/v1/posts',
    headers={'Authorization': 'Bearer sk_YOUR_API_KEY'},
    json={
        'content': 'Excited to share our latest product update!',
        'platforms': ['linkedin-connection-id'],
        'status': 'published',
    }
)

print('Published:', response.json()['data']['id'])

LinkedIn limits: 3,000 characters per post, supports images (up to 20MB), videos (up to 200MB, 10 minutes), documents (PDF up to 100MB), and carousel posts.

Step 3: Post to X (Twitter)

X requires concise content. Postpost automatically handles the 280-character limit and can create threads for longer content.

Via MCP

You: "Tweet this: Just shipped a major update to our scheduling engine.
AI agents can now post to 10 platforms with a single command.
The future of social media is autonomous. 🤖 postpost.dev"

OpenClaw: Publishing to X...

✓ Posted to X (@johndoe)
  Status: published

Via REST API

await fetch('https://api.postpost.dev/v1/posts', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    content: 'Just shipped a major update to our scheduling engine. AI agents can now post to 10 platforms with a single command. 🤖',
    platforms: ['x-twitter-connection-id'],
    status: 'published',
  }),
});

X limits: 280 characters (or 25,000 for Premium users), up to 4 images, 1 video (up to 140 seconds), or 1 GIF per post. Postpost auto-threads longer content.

Step 4: Post to Instagram & Threads

Instagram and Threads are both Meta platforms but have different content requirements.

Instagram via MCP

You: "Post to Instagram with this image [upload photo].
Caption: Behind the scenes of building an AI-powered social media tool.
Our team shipped 47 features this month. #startup #buildinpublic #AI"

OpenClaw: I'll upload the image and post to Instagram...

✓ Posted to Instagram (@johndoe.official)
  Type: image post
  Status: published

Threads via MCP

You: "Post to Threads: Hot take — AI agents will manage 80% of social media
within 2 years. Here's why: they never sleep, they optimize posting times
automatically, and they can manage 100 accounts simultaneously."

OpenClaw: Publishing to Threads...

✓ Posted to Threads (@johndoe.official)
  Status: published

REST API for Both

# Post to both Instagram and Threads simultaneously
import requests

# First, upload media for Instagram
upload_resp = requests.post(
    'https://api.postpost.dev/v1/upload',
    headers={'Authorization': 'Bearer sk_YOUR_API_KEY'},
    json={'fileName': 'product-photo.jpg', 'contentType': 'image/jpeg'}
)
upload_url = upload_resp.json()['data']['uploadUrl']

# Upload the actual file to the presigned URL
with open('product-photo.jpg', 'rb') as f:
    requests.put(upload_url, data=f, headers={'Content-Type': 'image/jpeg'})

# Create cross-platform post
response = requests.post(
    'https://api.postpost.dev/v1/posts',
    headers={'Authorization': 'Bearer sk_YOUR_API_KEY'},
    json={
        'content': 'Behind the scenes of building an AI-powered social media tool. 🚀',
        'platforms': ['instagram-connection-id', 'threads-connection-id'],
        'mediaUrls': [upload_resp.json()['data']['fileUrl']],
        'status': 'published',
    }
)

print('Posted to Instagram + Threads:', response.json()['data']['id'])

Instagram limits: 2,200 characters, requires at least one image or video, up to 10 carousel images, videos up to 60 seconds (Reels up to 90 seconds).

Threads limits: 500 characters, images up to 10, videos up to 5 minutes.

Step 5: Post to TikTok

TikTok focuses on video content but also supports photo posts and carousels.

Via MCP

You: "Upload this video to TikTok with the caption:
How I automated my entire social media with AI 🤖
#AI #automation #socialmedia #techtok"

OpenClaw: Uploading video and posting to TikTok...

✓ Posted to TikTok (@johndoe)
  Type: video
  Status: published

Via REST API

// Upload video first
const uploadResp = await fetch('https://api.postpost.dev/v1/upload', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    fileName: 'demo-video.mp4',
    contentType: 'video/mp4',
  }),
});
const { data: { uploadUrl, fileUrl } } = await uploadResp.json();

// Upload the video file
await fetch(uploadUrl, {
  method: 'PUT',
  body: videoBuffer,
  headers: { 'Content-Type': 'video/mp4' },
});

// Post to TikTok
await fetch('https://api.postpost.dev/v1/posts', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    content: 'How I automated my entire social media with AI 🤖 #AI #automation',
    platforms: ['tiktok-connection-id'],
    mediaUrls: [fileUrl],
    status: 'published',
  }),
});

TikTok limits: 2,200 characters, video up to 10 minutes (recommended 15-60 seconds), photo carousels up to 35 images.

Step 6: Post to YouTube

Postpost supports YouTube Shorts and community posts.

You: "Upload this short video to YouTube with title 'AI Social Media Automation in 60 Seconds'
and description: Watch how OpenClaw + Postpost automates posting to 10 platforms."

OpenClaw: Uploading to YouTube...

✓ Posted to YouTube (@johndoe)
  Type: Short
  Status: processing (YouTube processes videos asynchronously)

YouTube limits: Title up to 100 characters, description up to 5,000 characters, Shorts up to 60 seconds, regular videos up to 12 hours.

Step 7: Post to Facebook

You: "Post to my Facebook page: We're thrilled to announce our new AI integration!
Manage all your social accounts from a single conversation with your AI assistant.
Try it free → postpost.dev"

OpenClaw: Publishing to Facebook...

✓ Posted to Facebook (Acme Corp page)
  Status: published

# Python REST API
requests.post(
    'https://api.postpost.dev/v1/posts',
    headers={'Authorization': 'Bearer sk_YOUR_API_KEY'},
    json={
        'content': 'We are thrilled to announce our new AI integration!',
        'platforms': ['facebook-connection-id'],
        'status': 'published',
    }
)

Facebook limits: 63,206 characters, up to 10 images, video up to 240 minutes.

Step 8: Post to Bluesky, Mastodon & Telegram

Postpost also supports decentralized and messaging platforms.

Bluesky

You: "Post to Bluesky: The open web deserves open tools.
That's why we built MCP integration — any AI agent can now manage
your social media through an open protocol. postpost.dev"

OpenClaw: ✓ Posted to Bluesky (@johndoe.bsky.social)

Bluesky limits: 300 characters (with automatic facet detection for links and mentions), up to 4 images.

Mastodon

You: "Toot to my Mastodon: Open-source AI meets open-source social.
@openclaw + @postpost = autonomous social media management.
No walled gardens. #fediverse #opensource #AI"

OpenClaw: ✓ Posted to Mastodon (@johndoe@mastodon.social)

Mastodon limits: 500 characters (varies by instance), up to 4 images, video up to 40MB.

Telegram

You: "Send to my Telegram channel: 📢 New feature alert!
AI agents can now post to your Telegram channels automatically.
Connect your channel in Postpost and start automating."

OpenClaw: ✓ Sent to Telegram channel (@johndoe_updates)

Telegram limits: 4,096 characters, supports images, videos, documents, and formatted text with Markdown/HTML.

Cross-Platform Posting: All Platforms at Once

The real power comes from posting to multiple platforms simultaneously. OpenClaw handles this elegantly:

You: "Post this to ALL my connected accounts:
Big news — we just crossed 10,000 users! 🎉
Thank you to everyone who believed in us from day one.
Here's to the next 10,000. postpost.dev"

OpenClaw: I'll post to all 6 connected platforms...

✓ LinkedIn — published
✓ X (Twitter) — published
✓ Instagram — published (with default image)
✓ Threads — published
✓ Bluesky — published (auto-truncated to 300 chars)
✓ Telegram — published

Posted to 6 platforms successfully.

REST API for Cross-Platform

// Get all connections first
const connections = await fetch('https://api.postpost.dev/v1/connections', {
  headers: { 'Authorization': 'Bearer sk_YOUR_API_KEY' },
}).then(r => r.json());

// Post to all at once
const allPlatformIds = connections.data.map(c => c.id);

const post = await fetch('https://api.postpost.dev/v1/posts', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    content: 'Big news — we just crossed 10,000 users! 🎉',
    platforms: allPlatformIds,
    status: 'published',
  }),
}).then(r => r.json());

console.log(`Posted to ${allPlatformIds.length} platforms:`, post.data.id);

Scheduling Posts for Later

Schedule posts in advance — perfect for content calendars:

You: "Schedule a LinkedIn post for next Monday at 9am EST:
Monday motivation — The best time to start automating your social media was yesterday.
The second best time is now. postpost.dev/start"

OpenClaw: Scheduled for Monday, Feb 23 at 9:00 AM EST.

Post details:
  Platform: LinkedIn
  Status: scheduled
  Scheduled: 2026-02-23T14:00:00Z

# Python — Schedule a post for a specific time
from datetime import datetime, timedelta

next_monday = datetime.now() + timedelta(days=(7 - datetime.now().weekday()) % 7)
scheduled_time = next_monday.replace(hour=14, minute=0, second=0).isoformat() + 'Z'

requests.post(
    'https://api.postpost.dev/v1/posts',
    headers={'Authorization': 'Bearer sk_YOUR_API_KEY'},
    json={
        'content': 'Monday motivation — start automating today.',
        'platforms': ['linkedin-connection-id'],
        'scheduledTime': scheduled_time,
        'status': 'scheduled',
    }
)

Bulk Scheduling: A Week of Content in 60 Seconds

You: "Schedule these posts for the week:
- Monday 9am LinkedIn: 'Weekly industry roundup — top 5 AI developments'
- Tuesday 2pm X + LinkedIn: 'New blog post: How we reduced churn by 40%'
- Wednesday 10am Instagram: 'Team photo from our offsite' [attach image]
- Thursday 3pm X: 'Quick tip: Use AI agents to 10x your posting frequency'
- Friday 9am All platforms: 'Happy Friday! What are you building this weekend?'"

OpenClaw: Scheduling 5 posts across the week...

✓ Mon 9:00 AM — LinkedIn (1 platform)
✓ Tue 2:00 PM — X + LinkedIn (2 platforms)
✓ Wed 10:00 AM — Instagram (1 platform, with image)
✓ Thu 3:00 PM — X (1 platform)
✓ Fri 9:00 AM — All (6 platforms)

All 5 posts scheduled. Total: 11 platform posts.

LinkedIn Analytics: Track Your Performance

Postpost's MCP server includes dedicated LinkedIn analytics tools — the most comprehensive analytics available via MCP.

You: "How did my LinkedIn perform this week?"

OpenClaw: Fetching your LinkedIn analytics...

This week's performance (Feb 12–19):
• Posts published: 4
• Total impressions: 5,230
• Unique viewers: 2,180
• Total reactions: 67
• Comments: 12
• Shares: 8
• Engagement rate: 1.66%
• Follower growth: +34

Top post: "Product update announcement"
  → 2,100 impressions, 28 reactions, 5 comments

// REST API — Get LinkedIn account stats
const stats = await fetch(
  'https://api.postpost.dev/v1/linkedin/stats?connectionId=linkedin-id&period=7d',
  { headers: { 'Authorization': 'Bearer sk_YOUR_API_KEY' } }
).then(r => r.json());

console.log('Impressions:', stats.data.impressions);
console.log('Engagement rate:', stats.data.engagementRate);

Media Uploads: Images, Videos, and Documents

Postpost uses a 3-step presigned URL process for media uploads:

// Step 1: Request upload URL
const { data } = await fetch('https://api.postpost.dev/v1/upload', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    fileName: 'campaign-banner.jpg',
    contentType: 'image/jpeg',
  }),
}).then(r => r.json());

// Step 2: Upload file to presigned URL
await fetch(data.uploadUrl, {
  method: 'PUT',
  body: fileBuffer,
  headers: { 'Content-Type': 'image/jpeg' },
});

// Step 3: Use the file URL in your post
await fetch('https://api.postpost.dev/v1/posts', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_YOUR_API_KEY',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    content: 'Check out our new campaign!',
    platforms: ['linkedin-id', 'instagram-id', 'x-twitter-id'],
    mediaUrls: [data.fileUrl],
    status: 'published',
  }),
});

Via MCP, media handling is even simpler — just reference files or URLs and OpenClaw handles the upload process automatically.

Building an Autonomous Social Media Agent

Here's a complete example of an autonomous social media agent using Python with the MCP SDK to connect to Postpost:

# autonomous_social_agent.py
# Connect to Postpost MCP server programmatically

import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
from datetime import datetime, timedelta

POSTPOST_KEY = "sk_YOUR_API_KEY"
MCP_URL = "https://mcp.postpost.dev"

async def get_session():
    """Connect to Postpost MCP server."""
    headers = {"Authorization": f"Bearer {POSTPOST_KEY}"}
    async with streamablehttp_client(MCP_URL, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            yield session

async def post_to_all_platforms(content: str, schedule_time: str = None):
    """Post content to all connected platforms."""
    async for session in get_session():
        # Get connections
        connections = await session.call_tool("list_connections", {})

        # Create the post
        params = {
            "content": content,
            "platforms": "all",
            "status": "scheduled" if schedule_time else "published",
        }
        if schedule_time:
            params["scheduledTime"] = schedule_time

        result = await session.call_tool("create_post", params)
        return result.content[0].text

async def get_weekly_analytics():
    """Get LinkedIn analytics summary."""
    async for session in get_session():
        stats = await session.call_tool("linkedin_account_stats", {
            "period": "7d"
        })
        followers = await session.call_tool("linkedin_followers", {
            "period": "7d"
        })
        return {
            "stats": stats.content[0].text,
            "followers": followers.content[0].text,
        }

async def schedule_content_calendar(posts: list):
    """Schedule a batch of posts with optimal timing."""
    results = []
    for post in posts:
        result = await post_to_all_platforms(
            content=post["content"],
            schedule_time=post["time"],
        )
        results.append(result)
    return results

# Example usage
async def main():
    # Post immediately to all platforms
    await post_to_all_platforms(
        "🚀 Exciting update: Our AI agent now supports 10 social platforms!"
    )

    # Schedule a week of content
    base = datetime.now() + timedelta(days=1)
    calendar = [
        {
            "content": "Monday insight: AI is reshaping content creation.",
            "time": base.replace(hour=9, minute=0).isoformat() + "Z"
        },
        {
            "content": "Wednesday deep-dive: How we built our MCP integration.",
            "time": (base + timedelta(days=2)).replace(hour=14, minute=0).isoformat() + "Z"
        },
        {
            "content": "Friday wrap: This week in social media automation.",
            "time": (base + timedelta(days=4)).replace(hour=10, minute=0).isoformat() + "Z"
        },
    ]
    await schedule_content_calendar(calendar)

    # Check performance
    analytics = await get_weekly_analytics()
    print("Weekly performance:", analytics)

asyncio.run(main())

Using mcporter to Call Postpost Tools Directly

OpenClaw's mcporter skill lets you call any Postpost MCP tool directly from the command line — useful for scripting and automation:

# List all Postpost tools
mcporter list --http-url https://mcp.postpost.dev --name postpost

# List connected accounts
mcporter call postpost.list_connections

# Create a post
mcporter call postpost.create_post \
  content="Hello from mcporter!" \
  platforms='["linkedin-id"]' \
  status=published

# Get LinkedIn stats
mcporter call postpost.linkedin_account_stats period=7d

# Schedule a post
mcporter call postpost.create_post \
  content="Scheduled via CLI" \
  platforms='["linkedin-id","x-twitter-id"]' \
  scheduledTime="2026-02-25T14:00:00Z" \
  status=scheduled

Platform Quick Reference

Platform	Character Limit	Images	Video	Special
LinkedIn	3,000	Up to 20	Up to 200MB	Documents, carousels, articles
X (Twitter)	280 / 25,000*	Up to 4	Up to 140s	Auto-threading, polls
Instagram	2,200	Up to 10	Up to 90s	Reels, Stories, carousels
Threads	500	Up to 10	Up to 5min	Auto-threading
TikTok	2,200	Up to 35	Up to 10min	Photo carousels
YouTube	5,000 desc	Thumbnails	Up to 12h	Shorts (60s), community posts
Facebook	63,206	Up to 10	Up to 240min	Page posts, Reels
Bluesky	300	Up to 4	—	Facets (links/mentions)
Mastodon	500*	Up to 4	Up to 40MB	Content warnings, polls
Telegram	4,096	Unlimited	Up to 2GB	Markdown/HTML formatting

* X Premium / Mastodon varies by instance

Error Handling & Best Practices

When working with multiple platforms, handle failures gracefully:

// Robust cross-platform posting with error handling
async function postWithRetry(content, platforms, maxRetries = 2) {
  const response = await fetch('https://api.postpost.dev/v1/posts', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer sk_YOUR_API_KEY',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ content, platforms, status: 'published' }),
  });

  const result = await response.json();

  if (!response.ok) {
    if (response.status === 429) {
      // Rate limited — wait and retry
      const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
      console.log(`Rate limited. Retrying in ${retryAfter}s...`);
      await new Promise(r => setTimeout(r, retryAfter * 1000));
      return postWithRetry(content, platforms, maxRetries - 1);
    }
    throw new Error(`Post failed: ${result.error?.message || response.statusText}`);
  }

  // Check per-platform results
  for (const platformPost of result.data.posts) {
    if (platformPost.status === 'failed') {
      console.warn(`Failed on ${platformPost.platform}: ${platformPost.error}`);
    } else {
      console.log(`✓ ${platformPost.platform}: ${platformPost.status}`);
    }
  }

  return result;
}

Also Works With Claude Desktop, Cursor, and More

The same Postpost MCP server works with any MCP-compatible client — not just OpenClaw:

• Claude Desktop — Settings → Developer → Edit Config
• Claude Code — .mcp.json in project root or ~/.claude.json
• Cursor — .cursor/mcp.json in project root
• Windsurf — MCP settings panel
• Any MCP client — Streamable HTTP transport to https://mcp.postpost.dev

The MCP config format is the same across all clients — just the config file location changes:

{
  "mcpServers": {
    "postpost": {
      "type": "http",
      "url": "https://mcp.postpost.dev",
      "headers": {
        "Authorization": "Bearer sk_YOUR_API_KEY"
      }
    }
  }
}

What's Next

You now have everything you need to build an AI-powered social media management system. Here are some ideas to explore:

• Content repurposing — Ask OpenClaw to take a blog post and create platform-specific versions for each network
• Analytics-driven posting — Query your LinkedIn stats to find the best performing content types, then generate more of that
• Automated engagement — Use LinkedIn reactions tools to engage with your network's content
• Team management — Use Workspace tools to manage multiple team members' social accounts
• Content calendar automation — Build a script that generates and schedules an entire month of content

Get started at postpost.dev — plans start at $5.40/month with full API and MCP access. Read the full documentation at docs.postpost.dev/guides/mcp-server.