Last updated: August 31, 2026

Activepieces and X, without the developer portal

Activepieces does have an X piece. It has two actions, Create Tweet and Create Reply, no triggers, and it needs your own X developer app with four OAuth 1.0a keys, so X bills you per post. Route the flow through OpenTweet instead and you get scheduling, threads and 36 tools with no developer account.

This page is not a hit piece on a piece. Activepieces is the largest open source MCP toolkit around, MIT licensed in its Community Edition, and its Twitter action does what it says. It is just a thin wrapper on the X API you have to bring yourself, and that is now the expensive part.

7-day free trial. No X developer account needed.

What the Twitter piece actually contains

Read it in the repository rather than taking anyone's word for it. The community Twitter piece registers two actions and zero triggers, and its auth block asks for the full OAuth 1.0a set.

activepieces/packages/pieces/community/twitter

// packages/pieces/community/twitter, as of August 2026
actions:  createTweet, createReply
triggers: (none)

auth: consumerKey, consumerSecret, accessToken, accessTokenSecret
      validated against the X API v2 "me" endpoint

createTweet props: text (required), image_1, image_2, image_3

Three consequences fall out of that shape. There is no scheduling field, so a future post means a delay step or a cron trigger. There is no thread action, so a thread is a chain of Create Reply steps you sequence yourself and unwind by hand when one fails halfway. And there is no trigger, so nothing in Activepieces can start a flow because something happened on X.

The part that costs money is not the software

Activepieces is free to self host. The X API behind the piece is not. Since February 2026 X bills pay-per-use: $0.015 a post, and $0.20 for any post that contains a link. A flow that posts your blog RSS is a link post every time. At roughly 60 link posts a month you have already spent more on X than a year of Pro.

What you get by routing through OpenTweet

Same flow, one HTTP step instead of a developer portal.

Post now

One HTTP step with publish_now true, or opentweet_create_tweet from an agent.

Schedule

scheduled_date holds the post server side. No delay step, no flow run left waiting.

Threads

opentweet_create_thread ships a connected thread. The Twitter piece has no thread action.

36 tools

Posts, threads, articles, evergreen, media, and analytics over MCP.

Analytics

Read what worked and feed it back into the next flow run.

No X app

No developer portal, no four OAuth 1.0a keys, no per-post X billing.

Path one, the HTTP piece inside a flow

Every Activepieces install has the HTTP piece. Point it at OpenTweet and you are done. This works the same on Activepieces Cloud and on a self hosted instance, and it replaces the Twitter piece entirely.

Activepieces flow step

Piece:   HTTP
Action:  Send HTTP request
Method:  POST
URL:     https://opentweet.io/api/v1/posts

Headers:
  Authorization: Bearer ot_your_key
  Content-Type:  application/json

Body (JSON):
  {
    "text": "{{ steps.ai_step.output }}",
    "publish_now": true
  }

The route is /api/v1/posts. Swap publish_now for scheduled_date and the post waits on our servers, not in your flow. Full field reference in the API docs.

Path two, both MCP servers in one client

The reason people reach for Activepieces in 2026 is usually not the flow builder. It is that every piece is exposed as an MCP tool, so an agent in Claude Desktop, Cursor or Windsurf can reach a few hundred apps at once. OpenTweet slots in beside it as a second server rather than competing with it.

claude_desktop_config.json

{
  "mcpServers": {
    "activepieces": {
      "type": "http",
      "url": "<your Activepieces MCP URL from Settings>"
    },
    "opentweet": {
      "type": "http",
      "url": "https://mcp.opentweet.io/mcp",
      "headers": {
        "Authorization": "Bearer ot_your_key"
      }
    }
  }
}

Now the agent has the Activepieces catalogue for everything else and 36 X-native tools for X: publish, schedule, batch schedule, threads, articles, evergreen, media upload and analytics. It picks the right one without you writing a tool wrapper.

Every tool and argument is listed in the MCP docs, and the endpoint is the same one described on the Twitter MCP server page.

The REST fallback

When the post should come out of a script, a webhook handler or CI rather than out of a flow run, skip both. Same key, one endpoint.

post.sh

curl -X POST https://opentweet.io/api/v1/posts \
  -H "Authorization: Bearer ot_your_key" \
  -H "Content-Type: application/json" \
  -d '{"text":"New release is out. Changelog in the replies.","publish_now":true}'

# Schedule instead of publishing now:
#   {"text":"...","scheduled_date":"2026-09-02T09:00:00Z"}

When the Twitter piece is the right call

Being honest about this is cheaper than being wrong about it.

Keep the Twitter piece if

You already hold an X developer app for other reasons, your volume is low, your posts rarely carry links, and you want zero third parties between the flow and X. Two actions is enough for a lot of automations.

Switch the step if

You post links, you want scheduling that does not hold a run open, you need threads or X Articles, you run more than one X account, or you would rather not maintain OAuth 1.0a credentials that break quietly when someone rotates a key.

The same endpoint works from n8n, Make, and Zapier. If you are still choosing a platform, OpenTweet vs n8n covers the same ground for the other open source option.

Frequently asked questions

Does Activepieces have a Twitter or X piece?

Yes. The community Twitter piece ships two actions, Create Tweet and Create Reply, and no triggers. Create Tweet takes text plus up to three images in the fields image_1, image_2 and image_3. Create Reply takes a tweet id, text and the same three image fields. That is the whole surface as of August 2026.

What credentials does the Activepieces Twitter piece need?

Four OAuth 1.0a values from the X developer portal: Api Key, Api Key Secret, Access Token and Access Token Secret. Your app has to be set to Read and write, of type Native App, with the callback set to your_website_url/redirect. Activepieces validates the connection by calling the X API v2 me endpoint.

So Activepieces posting to X is not free?

The Activepieces software is free and MIT licensed for the Community Edition. The X API behind the piece is not. You bring your own X developer app, so X bills you directly: since February 2026 that is $0.015 per post and $0.20 for a post that contains a link. OpenTweet holds the X connection instead, at $11.99 a month flat.

Can Activepieces schedule a tweet for later?

Not through the Twitter piece, which has no scheduling field and no thread action. You can approximate it with a delay step or a cron trigger, which keeps a flow run or a schedule occupied for the wait. OpenTweet stores the post server side with opentweet_schedule_tweet and publishes at the time you set, with nothing holding a run open.

How do I post to X from an Activepieces flow without an X developer account?

Use the built-in HTTP piece. Send POST to https://opentweet.io/api/v1/posts with an Authorization header of Bearer ot_your_key and a JSON body of text plus either publish_now true or a scheduled_date. No X app, no OAuth 1.0a signing, no per-post X billing.

What is the Activepieces MCP server, and how does OpenTweet fit next to it?

Activepieces exposes its pieces as MCP tools so a client such as Claude Desktop, Cursor or Windsurf can call them. Its README describes 280+ pieces available that way and the repository is titled around roughly 400 MCP servers. OpenTweet is a separate MCP server at https://mcp.opentweet.io/mcp. Add both to the same client config and the agent gets the Activepieces catalogue plus 36 X-specific tools.

Is Activepieces really open source?

The Community Edition is MIT licensed. Enterprise features are under a separate commercial license, which the README states directly. That split is normal for this category and it does not affect the Twitter piece, which lives in the community pieces directory.

Wire any automation platform to X

One key, one endpoint, and the same 36 tools everywhere.

OpenTweet vs the X API

Post, schedule, and automate X without a developer account or the $200/mo minimum.

X DM outreach, human-approved

Find and qualify leads, AI-draft DMs, approve each one, and drip-send from your own account via API or MCP.

Post to X without an API

The clean, account-safe way to post to X from your code or an AI agent.

Twitter MCP Server

Give Claude, Cursor, and OpenClaw the ability to post to X. 36 tools included.

Developer docs

Quickstart, API keys, MCP setup, and the REST reference for posting to X from code or an agent.

XMCP vs OpenTweet

X's official MCP server bills per API call and cannot schedule. Compare it with the flat-fee hosted MCP.

MCP for AI agents

Connect your AI client to X in under two minutes, no X developer account.

Developer API and keys

REST endpoints, one bearer key, and usage tracking. Build on OpenTweet.

OpenTweet for AI agents

The posting layer for autonomous agents and automations that live on X.

Build an AI Twitter persona

Give your AI agent its own X account. Setup, cadence, and the rules that keep it safe.

Best MCP servers for social media

The 2026 ranked list. How the hosted OpenTweet MCP compares with the official X MCP and others.

Cheapest way to post to X via code

Flat fee vs pay-per-use. Why the $0.20 per-link fee flips the math past ~60 posts a month.

Drop the developer portal from your flow

Connect X, copy your key, replace one step.

$11.99/month, API included. Cancel anytime.