Getting Started

Welcome to Browserman! This guide will help you get up and running with browser automation in minutes.

What is Browserman?

Browserman is a browser automation platform that allows you to:

• Automate social media - Post, engage, and manage content across multiple platforms
• Manage multiple accounts - Handle dozens of accounts securely in one place
• Integrate with AI - Use with Claude, ChatGPT via Model Context Protocol (MCP)
• Scale operations - From a few tasks to thousands per day

Quick Start in 3 Steps

1. Create an Account

Visit app.browserman.run and sign up:

1. Click Sign Up
2. Enter your email and password
3. Verify your email
4. Log in to the dashboard

2. Connect Your First Account

Bind a social media account to start automating:

1. Go to Accounts in the sidebar
2. Click Add Account
3. Choose a platform (Twitter, Xueqiu, etc.)
4. Complete OAuth authorization or enter credentials
5. Give your account a name

3. Make Your First Request

Choose your preferred method:

Option A: Use the Dashboard

1. Go to Tasks > New Task
2. Select your account
3. Choose an action (e.g., "Post Tweet")
4. Fill in the parameters
5. Click Execute

Option B: Use the API

curl -X POST https://api.browserman.run/api/tasks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "platform": "twitter",
    "tool": "createTweet",
    "accountName": "my-account",
    "parameters": {
      "text": "Hello from Browserman! 🚀"
    }
  }'

Option C: Use with Claude (MCP)

1. Configure MCP
2. Open Claude Desktop
3. Say: "Post a tweet saying 'Hello from Browserman!' using my account"

Core Concepts

Platforms

Browserman supports multiple platforms:

• Twitter/X
• Xueqiu (雪球)
• Eastmoney (东方财富)
• Tonghuashun (同花顺)

Each platform has specific tools (actions) you can perform.

Accounts

Accounts are your connected social media profiles. Key points:

• Each account has a unique name
• One platform can have multiple accounts
• Accounts are securely encrypted and stored

Tools

Tools are actions you can perform on a platform:

• createTweet - Post a tweet
• likeTweet - Like a tweet
• xueqiu_post - Post to Xueqiu
• And many more...

View all available tools: API Reference

Tasks

Tasks are individual automation jobs:

• Each API call creates a task
• Tasks have states: pending, processing, completed, failed
• You can track task status and results

Execution Engines

Browserman offers two execution modes:

Lite Mode (Default)

• Fast and efficient
• Lower resource usage
• Good for most tasks

Full Mode

• Complete browser emulation
• Better platform compatibility
• Recommended for sensitive operations

Specify in your request:

{
  "preferredEngine": "full"
}

Your First Automation

Let's create a complete automation workflow:

Example: Daily Twitter Update

Goal: Post a daily update to Twitter

Using the API:

const response = await fetch('https://api.browserman.run/api/tasks', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    platform: 'twitter',
    tool: 'createTweet',
    accountName: 'personal-twitter',
    parameters: {
      text: 'Daily update: Building amazing things! 🚀'
    }
  })
});

const result = await response.json();
console.log('Task ID:', result.taskId);

Using MCP with Claude:

Simply tell Claude:

Post a daily update to my Twitter account saying
"Daily update: Building amazing things! 🚀"

Example: Multi-Platform Posting

Goal: Post the same message to Twitter and Xueqiu

Using MCP:

Post "Exciting market trends today!" to both my
Twitter and Xueqiu accounts

Claude will automatically:

1. Find your connected accounts
2. Make multiple tool calls
3. Report the results

Authentication

API Keys

To use the REST API, you need an API key:

1. Go to Settings > API Keys in the dashboard
2. Click Generate New Key
3. Give it a name (e.g., "Production API")
4. Copy the key immediately (shown only once)
5. Store it securely

Using API Keys:

# In headers
Authorization: Bearer YOUR_API_KEY

# Example
curl https://api.browserman.run/api/platforms \
  -H "Authorization: Bearer sk_live_xxxxxxxxxxxx"

MCP Authentication

For MCP, configure the API key in your Claude config:

{
  "mcpServers": {
    "browserman": {
      "url": "https://mcp.browserman.run",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

See the full MCP Configuration Guide.

Understanding API Endpoints

Base URL

https://api.browserman.run

Key Endpoints

Platforms

GET /api/platforms

List all supported platforms and their tools.

Platform Schema

GET /api/platforms/schema

Get detailed schema for all platforms.

Accounts

GET /api/accounts

List your connected accounts.

Tasks

POST /api/tasks
GET /api/tasks/:taskId

Create and check tasks.

See the API Reference for complete documentation.

Best Practices

1. Use Descriptive Account Names

Good:

personal-twitter
work-xueqiu
brand-official

Bad:

account1
test
a

2. Handle Rate Limits

Platforms have rate limits. Spread out your requests:

// Bad: Too fast
for (let i = 0; i < 100; i++) {
  await postTweet();
}

// Good: Add delays
for (let i = 0; i < 100; i++) {
  await postTweet();
  await sleep(60000); // 1 minute delay
}

3. Check Task Status

Don't assume tasks succeeded. Always check:

const task = await createTask();
const status = await checkTaskStatus(task.taskId);

if (status.state === 'completed') {
  console.log('Success!', status.result);
} else if (status.state === 'failed') {
  console.error('Failed:', status.error);
}

4. Use Full Mode When Needed

For important operations or when facing detection issues:

{
  "preferredEngine": "full"
}

5. Secure Your API Keys

• Never commit API keys to version control
• Use environment variables
• Rotate keys regularly
• Create separate keys for different environments

Common Workflows

Social Media Management

// Morning routine
await postTweet('Good morning! ☀️');
await postToXueqiu('Market analysis for today...');

// Engagement
await likeTweet(tweetUrl);
await retweet(tweetUrl);

// Evening summary
await postTweet('Daily summary: ...');

Content Distribution

// Post to multiple platforms
const content = generateContent();

await Promise.all([
  postTweet(content.twitter),
  postToXueqiu(content.xueqiu),
  postToTonghuashun(content.tonghuashun)
]);

Monitoring and Alerts

// Check for important updates
const mentions = await getMentions();

if (mentions.some(m => m.important)) {
  await postTweet('Responding to important mention...');
}

Troubleshooting

Issue: "Account not found"

Solution:

• Check account name spelling
• Use GET /api/accounts to list available accounts
• Ensure account is properly connected

Issue: "Rate limit exceeded"

Solution:

• Add delays between requests
• Check platform-specific limits
• Spread requests over time

Issue: "Authentication failed"

Solution:

• Verify API key is correct
• Check if key is expired
• Ensure "Bearer " prefix is included

See the MCP Troubleshooting Guide for more help.

Next Steps

Now that you understand the basics:

1. Bind more accounts - Connect all your social media
2. Configure MCP - Use with Claude or ChatGPT
3. Explore the API - Learn about all available tools
4. View examples - Get inspired by real use cases

Need Help?

• Documentation - Check our comprehensive guides
• Dashboard - Visit app.browserman.run
• Support - Contact us through the dashboard
• Community - Join our Discord (if available)

Happy automating! 🚀