Make.com Twitter (X) integration in 2026

#What happened to Make's Twitter (X) app

Make's X (formerly Twitter) app is gone for good: Make pulled it from the app search on April 3, 2025, and scenarios that still used its modules began failing on May 30, 2025. Make's release note (opens in a new tab) gives one reason, X's API policy requirements and pricing, which it says rule out "a reasonable integration" for its customers.

Nothing has been reinstated since, as the dates show:

• April 3, 2025

  What changed in Make

  The X app leaves the app search; no new X scenarios

• May 30, 2025

  What changed in Make

  Existing X scenarios stop; they still open but fail on every run

• January 19, 2026

  What changed in Make

  Make's notice is last updated, with no change of course

• November 2, 2026

  What changed in Make

  Still no X app in Make's integrations (checked for this guide)

Make (formerly Integromat) points customers who posted to X toward social media management apps, and its xAI app, which reaches Grok's models, was not affected. Neither one reads posts, profiles or followers from X. Reading X data now takes a request from Make's HTTP app, which talks to any service with a REST API.

Calling the official X API from that module needs an X developer app, a Bearer token or OAuth connection, and prepaid credits: $0.005 per post read and $0.010 per user or follower, with pay-per-use capped at 3M post reads a month, according to X's pricing page (opens in a new tab). From November 22, 2026, X also bills each post's author as a user read, so a post with its author comes to $0.015 (X's notice of October 23 (opens in a new tab)).

#Read X data in Make with Sorsa API

Sorsa API, a Twitter (X) API and scraper, fills the gap with one API key and the HTTP app every Make plan already has. To read tweets, mentions and followers in a Make scenario, use Sorsa API: 20 posts or 200 followers per request, search back to 2006 and 20 requests per second on every plan, with no X developer account and no OAuth connection to renew.

The steps build a keyword search that returns the newest posts. Every other job below reuses the same keychain and module with a different URL.

1. Get an API key. Sign up and copy the key from the dashboard. The first 100 requests are free, need no card and never expire.

2. Store the key in a keychain. Add the HTTP app's Make a request module and set Authentication type to API key. Under Credentials, create a keychain: paste the key into Key, set API key placement to In the header and API key parameter name to ApiKey. The key then stays out of the module's fields, and you can rotate it later under Keys.

3. Point the module at Sorsa API. Set URL to https://api.sorsa.io/v3/search-tweets and Method to POST.

4. Send the search as JSON. Set Body content type to application/JSON, Body input method to JSON string, and enter a body with two fields: query takes any X search, operators included, and order takes latest or popular. The curl below is the same request, handy for testing a query before it goes into Make.

   curl -X POST "https://api.sorsa.io/v3/search-tweets" \
     -H "ApiKey: YOUR_API_KEY" \
     -H "Content-Type: application/json" \
     -d '{"query": "make.com lang:en -filter:retweets", "order": "latest"}'
   

5. Parse the response and run once. Set Parse response to Yes and click Run once. The module's output now holds Data with a tweets array and a next_cursor, and every later module can map their fields.

   {
     "tweets": [
       {
         "id": "1985417630058127650",
         "full_text": "Rebuilt our launch tracker as a make.com scenario.",
         "created_at": "2026-11-02T08:41:19Z",
         "lang": "en",
         "likes_count": 18,
         "retweet_count": 2,
         "reply_count": 4,
         "view_count": 1290,
         "user": {
           "id": "1601177354291937280",
           "username": "scenario_builder_notes",
           "display_name": "Scenario Builder Notes",
           "followers_count": 2315
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG4V8kQ2W"
   }
   

   Show full response

Add Flow Control > Iterator after the HTTP module and set its Array to the tweets array under Data. Each post then travels through the scenario as its own bundle with its author's full profile inside, so a sheet row or a Slack message can show the handle and follower count without a second request. A 401 answer means the key is wrong, and a 403 means the key is missing or the account has no requests left.

#Which endpoint for which Make scenario

Every Make job maps to one Sorsa API endpoint, and the endpoint's method decides how the HTTP module pages through it. The table lists the endpoints Make scenarios use most; the full list of Sorsa API endpoints has all 45.

• Keyword or hashtag search

  Endpoint

  POST /search-tweets (opens in a new tab)

  What you send

  query, order

  Per request

  About 20 posts

  Paging in Make

  Repeater loop

• One account's posts

  Endpoint

  POST /user-tweets (opens in a new tab)

  What you send

  username

  Per request

  About 20 posts

  Paging in Make

  Repeater loop

• Brand mentions

  Endpoint

  POST /mentions (opens in a new tab)

  What you send

  query (the handle), min_likes, since_date

  Per request

  About 20 posts

  Paging in Make

  Repeater loop

• An X List feed

  Endpoint

  GET /list-tweets (opens in a new tab)

  What you send

  list_id

  Per request

  About 20 posts

  Paging in Make

  Built-in pagination

• Follower export

  Endpoint

  GET /followers (opens in a new tab)

  What you send

  username

  Per request

  Up to 200 followers

  Paging in Make

  Built-in pagination

A monitor that runs every few minutes rarely needs a second page, because about 20 of the newest posts per request cover most keywords between two runs. Pagination matters for backfills and exports, and the next section sets it up.

The builder below writes the module for your job: pick it, type a query, handle or List ID, and copy the settings or download a blueprint with the HTTP module and an Iterator. In Make, open an empty scenario, choose Import blueprint from the three-dot menu and select the file, then paste your key into the ApiKey header or switch the module to the keychain from step 2.

{
  "name": "Sorsa API: search-tweets to Iterator",
  "flow": [
    {
      "id": 1,
      "module": "http:ActionSendData",
      "version": 3,
      "parameters": {
        "handleErrors": false,
        "useNewZLibDeCompress": true
      },
      "mapper": {
        "ca": "",
        "qs": [],
        "url": "https://api.sorsa.io/v3/search-tweets",
        "gzip": true,
        "method": "post",
        "headers": [
          {
            "name": "ApiKey",
            "value": "YOUR_API_KEY"
          }
        ],
        "timeout": "",
        "useMtls": false,
        "authPass": "",
        "authUser": "",
        "bodyType": "raw",
        "serializeUrl": false,
        "shareCookies": false,
        "parseResponse": true,
        "followRedirect": true,
        "useQuerystring": false,
        "followAllRedirects": false,
        "rejectUnauthorized": true,
        "contentType": "application/json",
        "data": "{\"query\": \"make.com lang:en -filter:retweets\", \"order\": \"latest\"}"
      },
      "metadata": {
        "designer": {
          "x": 0,
          "y": 0
        }
      }
    },
    {
      "id": 2,
      "module": "builtin:BasicFeeder",
      "version": 1,
      "parameters": {},
      "mapper": {
        "array": "{{1.data.tweets}}"
      },
      "metadata": {
        "designer": {
          "x": 300,
          "y": 0
        }
      }
    }
  ],
  "metadata": {
    "instant": false,
    "version": 1,
    "scenario": {
      "roundtrips": 1,
      "maxErrors": 3,
      "autoCommit": true,
      "autoCommitTriggerLast": true,
      "sequential": false,
      "confidential": false,
      "dataloss": false,
      "dlq": false,
      "freshVariables": false
    },
    "designer": {
      "orphans": []
    }
  }
}

#Pagination: follow next_cursor in Make

Sorsa API pages with a cursor: each response carries next_cursor, a token that points to the next page, and the last page returns it empty. How Make follows the cursor depends on whether the endpoint expects it in the query string or in the JSON body.

GET endpoints: the HTTP module's built-in pagination

The current HTTP module pages by itself with its Token or cursor-based pagination type, and it sends the cursor as a query parameter, which is where Sorsa API's GET list endpoints read it. Make's HTTP documentation (opens in a new tab) lists the fields; for /followers and /list-tweets they take these values:

• Pagination type: Token or cursor-based.
• Items path: users for followers, tweets for a List feed.
• Next page token/cursor path and Page token/cursor parameter name: both next_cursor.
• Page size parameter: empty, since Sorsa API sets the page size.
• Output format and Limit: Array of items, and the most items one run may return, up to 10K.

A Limit of 10K followers takes 50 requests at 200 followers each. The same settings work on /follows, /verified-followers, /list-members and /list-followers.

POST endpoints: a Repeater loop

Search, timelines and mentions are POST endpoints that take next_cursor in the JSON body, as the API reference defines them, so the built-in pagination can't drive them. Five modules can:

1. Repeat. Add Flow Control > Repeater with Repeats set to the most pages one run may read, for example 10.

2. Read the cursor. Add Tools > Get variable for a variable named cursor.

3. Stop at the end. Put a filter after it that passes the first repetition, or a cursor that exists.

4. Request the page. Add the HTTP module from the steps above and add next_cursor to the body, mapped to the variable. Wrap that field in Make's if() function so the first request leaves it out.

5. Keep the next cursor. Add Tools > Set variable that stores the response's next_cursor as cursor, with Variable lifetime set to One execution.

Repetitions after the last page stop at the filter, so they spend a Make credit and no Sorsa API request.

Good to know

Keep the built-in pagination off /search-tweets, /user-tweets and /mentions. It sends the cursor in the query string, while the API reference defines those endpoints with the cursor in the JSON body, so the Repeater loop is the way to page them.

#New posts to Google Sheets or Slack

A Make scenario can log every new post about a keyword or from a set of accounts, each one once and without duplicates, with four modules: the HTTP module, an Iterator, a filter and the destination. Make has no trigger for new posts on X, and Sorsa API has no webhooks, so the scenario polls on a schedule and lets only new posts through.

1. Schedule it. Set the scenario to run at regular intervals, for example every 15 minutes, Make's default.

2. Ask for the newest posts. Use the HTTP module on POST /search-tweets with order set to latest. To watch accounts, join them as from: operators with OR in one query. For hundreds of accounts, add them to a public X List and call GET /list-tweets with its list_id: one request reads the feed of a List of up to 5,000 accounts.

3. Split the posts. Add an Iterator on the tweets array.

4. Let only new posts pass. Set a filter on the link after the Iterator: created_at later than the run time minus 16 minutes, which Make writes as addMinutes(now; -16). The spare minute covers schedule drift, and filters cost no credits.

5. Write or send. Add Google Sheets > Add a row or Slack > Create a message, and map full_text, user.username, created_at and id.

For strict dedupe, add a Data store keyed on the post ID after the filter: Check the existence of a record, let through only posts that aren't stored yet, and Add/replace a record once the row is written. Match IDs as exact text keys. A post ID has 19 digits, more than a number in a formula holds exactly, and sorting IDs as text puts "9" after "10" whenever the lengths differ.

The guide to export Twitter data to Google Sheets covers the sheet side: column layout, large follower lists and an Apps Script route that needs no Make at all. For alerts within seconds and keyword monitoring at scale, see real-time Twitter monitoring.

#What X data in Make costs

A Make scenario that reads X data pays two bills: one to the data source and one in Make credits. Sorsa API charges per request, not per post: a search page of about 20 posts is one request, so posts cost from $0.07 per 1,000 against $5.00 per 1,000 on the official X API, and failed requests are never charged.

The gap grows on followers and on posts with authors, because Sorsa API returns 200 followers per request and every post with its author's profile included:

• Posts from search, timelines, mentions and Lists

  Sorsa API, per 1,000

  from $0.07

  Official X API, per 1,000

  $5.00

• Posts with their authors, from November 22, 2026

  Sorsa API, per 1,000

  from $0.07

  Official X API, per 1,000

  $15.00

• Followers

  Sorsa API, per 1,000

  from $0.007

  Official X API, per 1,000

  $10.00

• Profiles looked up in batches of 100

  Sorsa API, per 1,000

  from $0.014

  Official X API, per 1,000

  $10.00

Make bills its side per module run: one credit per operation, and a module runs once for every bundle it processes, as Make's guide to credits (opens in a new tab) explains. The HTTP module and the Iterator cost one credit each per run, each module after the Iterator costs one credit per post that reaches it, and filters and routers cost nothing. Make's Free plan includes 1,000 credits a month.

A 15-minute schedule runs 2,880 times in a 30-day month: 2,880 Sorsa API requests, which fit the Starter plan's 10K, and 5,760 Make credits before the first post is written. The calculator below adds up both bills for your schedule.

Price is one of five checks before you wire an X data source into Make. Sorsa API passes each one with a number:

• Setup

  Sorsa API in a Make scenario

  One API key in a keychain; no developer app and no OAuth connection to renew

• Speed

  Sorsa API in a Make scenario

  20 requests per second on every plan, free accounts included

• Coverage

  Sorsa API in a Make scenario

  Search back to 2006, timelines, mentions, followers and Lists across 45 endpoints

• Account safety

  Sorsa API in a Make scenario

  Never asks for your X login or cookies, so no X account of yours is at risk

• Reliability

  Sorsa API in a Make scenario

  In production since 2022; a stable response schema, so your fields stay the same

#Build your first X scenario in Make

Make dropped its X app in 2025, and one HTTP module with a key header now does all the reading. Build that module on Sorsa API: an ApiKey keychain instead of an OAuth app, 20 posts or 200 followers per request, from $0.07 per 1,000 tweets, and 100 free requests that cover your first 2,000 posts.

Working in another tool? The guides to the Twitter API in n8n and the Twitter API in Zapier set up the same reads in those platforms.

#FAQ