Twitter API in n8n without OAuth

#What the n8n X node can read

The n8n X node can read two things: one user profile and a search of posts from the last 7 days. Its other six operations write to X. That list comes from n8n's X node documentation (opens in a new tab), and the node's source on GitHub shows the search calling X's /tweets/search/recent endpoint, which is limited to a week.

• Tweet

  Operations

  Create or reply, delete, like, retweet

  Reads X data

  No

• Tweet

  Operations

  Search

  Reads X data

  Posts from the last 7 days

• User

  Operations

  Get a user

  Reads X data

  One profile per call

• Direct message

  Operations

  Create

  Reads X data

  No

• List

  Operations

  Add a member

  Reads X data

  No

Nothing in the node returns an account's timeline, its mentions, its followers or the posts of an X List, and n8n has no trigger node that fires on a new post.

To connect the node at all, you create an X developer account and an app, set its OAuth2 permissions and callback URL, and paste the Client ID and Secret into n8n, as n8n's X credentials page (opens in a new tab) describes. Every read is then billed by X from prepaid credits: $0.005 per post and $0.010 per user, 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, an author profile returned with a post costs $0.010 more, 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 n8n with Sorsa API

Sorsa API, a Twitter (X) API and scraper, plugs into n8n's HTTP Request node with one header, so reading X data takes one credential and one node. For reading tweets, mentions and followers in n8n, use Sorsa API: 20 tweets or 200 followers per request, search back to 2006 and 20 requests per second on every plan, with no developer account and no OAuth app.

The steps below build a keyword search. Every other job uses the same credential and the same node with a different endpoint.

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. Create a Header Auth credential. In n8n, open Credentials, create a new Header Auth credential, set Name to ApiKey and Value to your key. The key then stays out of every workflow you export or share.

3. Add an HTTP Request node. Set Method to POST and URL to https://api.sorsa.io/v3/search-tweets. Under Authentication choose Generic Credential Type, then Header Auth, then the credential from step 2.

4. Send the search as JSON. Turn on Send Body, keep Body Content Type on JSON, and add two body parameters: query with any X search, operators included, and order with latest or popular. A shortcut: choose Import cURL in the node and paste the command below, then move the key from the header field into your credential.

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

5. Split the posts into items. Add a Split Out node with Fields To Split Out set to tweets. Each post then travels through the workflow as its own item, ready for a Filter, an IF node, Google Sheets or Slack.

   {
     "tweets": [
       {
         "id": "1985402186610352215",
         "full_text": "Our n8n flow now posts every release note to Slack.",
         "created_at": "2026-11-02T09:14:07Z",
         "lang": "en",
         "likes_count": 42,
         "retweet_count": 6,
         "reply_count": 3,
         "view_count": 2810,
         "user": {
           "id": "1592041833471827968",
           "username": "nightly_build_notes",
           "display_name": "Nightly Build Notes",
           "followers_count": 1840
         }
       }
     ],
     "next_cursor": "DAADDAABCgABG4V2Yz9W"
   }
   

   Show full response

Each post carries its author's full profile, so a Slack message or a sheet row can show the handle and follower count with no second call. A 401 answer means the key is wrong, and a 403 means the header is missing or the account has no requests left.

#Pagination: follow next_cursor in n8n

The HTTP Request node can fetch every page by itself: it sends the next_cursor from each response with the next request and stops when the cursor comes back empty. A cursor is a token that points to the next page of results. Search, timelines and mentions return about 20 posts per page, and followers come 200 per page.

Open Options in the HTTP Request node and add Pagination. The panel below holds the five settings that loop through Sorsa API's cursor; switch it to GET for endpoints such as /followers and copy each expression straight into n8n.

Good to know

Leave Pagination Complete When off its default. "Response Is Empty" never fires on a JSON object, so the node keeps requesting the last page until n8n stops it with "The returned response was identical 5x", and every one of those calls is a request. The Complete Expression above stops on the first page that has no cursor.

Every page comes out of the node as one item holding its own tweets or users array. A Split Out node right after it turns all pages into one flat list of posts or profiles.

#Which endpoint for which n8n workflow

Each n8n job maps to one Sorsa API endpoint, and all of them run through the same Header Auth credential. The table lists the endpoints n8n workflows 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

• One account's posts

  Endpoint

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

  What you send

  username, type

  Per request

  About 20 posts

• 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

• Follower export

  Endpoint

  GET /followers (opens in a new tab)

  What you send

  username

  Per request

  Up to 200 followers

• An X List feed

  Endpoint

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

  What you send

  list_id

  Per request

  About 20 posts

• Enrich a column of handles

  Endpoint

  GET /info-batch (opens in a new tab)

  What you send

  usernames, repeated

  Per request

  Up to 100 profiles

For /info-batch, send usernames as an array and set the node's Array Format in Query Parameters option to No Brackets, which repeats the parameter once per handle.

The builder below writes the HTTP Request node for your job. Pick a job, type a query or handle and the number of pages, then copy the JSON and paste it into an n8n canvas with Ctrl+V or Cmd+V.

{
  "nodes": [
    {
      "name": "Sorsa API: search-tweets",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        0,
        0
      ],
      "parameters": {
        "method": "POST",
        "url": "https://api.sorsa.io/v3/search-tweets",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpHeaderAuth",
        "sendBody": true,
        "bodyParameters": {
          "parameters": [
            {
              "name": "query",
              "value": "n8n lang:en -filter:retweets"
            },
            {
              "name": "order",
              "value": "latest"
            }
          ]
        },
        "options": {
          "pagination": {
            "pagination": {
              "paginationMode": "updateAParameterInEachRequest",
              "parameters": {
                "parameters": [
                  {
                    "type": "body",
                    "name": "next_cursor",
                    "value": "={{ $response.body.next_cursor }}"
                  }
                ]
              },
              "paginationCompleteWhen": "other",
              "completeExpression": "={{ !$response.body.next_cursor }}",
              "limitPagesFetched": true,
              "maxRequests": 5,
              "requestInterval": 50
            }
          }
        }
      }
    },
    {
      "name": "One item per post",
      "type": "n8n-nodes-base.splitOut",
      "typeVersion": 1,
      "position": [
        240,
        0
      ],
      "parameters": {
        "fieldToSplitOut": "tweets",
        "options": {}
      }
    }
  ],
  "connections": {
    "Sorsa API: search-tweets": {
      "main": [
        [
          {
            "node": "One item per post",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

#Recipe: new posts from accounts to Slack

An n8n workflow can post every new tweet from a set of accounts to Slack with five nodes and no code: a schedule, one search request, Split Out, Remove Duplicates and the Slack node. n8n has no trigger for new posts, so the workflow asks for the latest posts every few minutes and drops the ones it has already seen.

1. Schedule it. A Schedule Trigger every 5 minutes.

2. Ask for the newest posts. POST /search-tweets with from: for each account joined by OR and order set to latest. One request covers every account in the query. For hundreds of accounts, put them in 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. Split Out on tweets.

4. Drop what you have seen. A Remove Duplicates node with Operation set to Remove Items Processed in Previous Executions and Keep Items Where set to Value Is New. Drag the post's id field into Value to Dedupe On. Post IDs are unique, so only new posts pass.

5. Send the message. Connect the Slack node, or Google Sheets or email, and use the text field the workflow builds.

The node builder above writes this whole workflow. Choose New posts alert, type the accounts to watch, copy the JSON and paste it into an empty canvas: it holds steps 1 to 4 and the message text. Pick your Header Auth credential in the HTTP Request node, add your Slack node at the end, and publish the workflow.

The first run passes the latest 20 posts through, because Remove Duplicates has seen nothing yet; from the second run on, only new posts reach Slack. A 5-minute schedule runs 8,640 times in a 30-day month at one request per run, which fits inside the Starter plan's 10K requests. For polling every few seconds, Lists and keyword alerts at scale, the guide to real-time Twitter monitoring goes further.

#Recipe: export followers to Google Sheets

A follower export in n8n is one HTTP Request node on GET /followers with query pagination, a Split Out node on users and a Google Sheets node that appends rows. Each request returns up to 200 follower profiles, so an account with 50K followers takes 250 requests and fits in one run.

1. Start it by hand. A Manual Trigger, since a full list is a one-off job.

2. Request the followers. An HTTP Request node with Method GET on /followers at the same base URL, Send Query Parameters on and username set to the account. Turn on pagination as above with Type Query, and raise Max Pages to the follower count divided by 200.

3. Split the profiles. Split Out on users.

4. Append to the sheet. A Google Sheets node with Append Row, mapping id, username, display_name, followers_count, location and created_at to columns.

When one workflow exports many accounts, the HTTP Request node runs once per incoming item. Set its Batching option to 20 items per batch with a Batch Interval of 1,000, one second, and n8n stays at 20 requests per second. If a burst still meets a 429, turn on Retry On Fail in the node's settings. The full method for very large lists, files and Excel quirks is in the guide to export Twitter followers.

#What reading X data in n8n costs

Reading posts through Sorsa API in n8n costs from $0.07 per 1,000 tweets, against $5.00 per 1,000 posts on the official X API that the X node uses. You pay per request, not per item: a search page of 20 posts is one request, and failed requests are never charged.

Followers show the widest gap: from $0.007 per 1,000 on Sorsa API against $10.00 on the official X API, because Sorsa API returns 200 per request and X bills each one.

• Posts from search, timelines, mentions, Lists

  Sorsa API, per 1,000

  from $0.07

  Official X API, per 1,000

  $5.00

• Posts with their authors, from Nov 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

Price is one of five things to check before you wire an X data source into n8n, and Sorsa API meets each with a number:

• Setup: one header in a Header Auth credential, against a developer app, OAuth2 and a callback URL.
• Speed: 20 requests per second on every plan, free accounts included.
• Coverage: search back to 2006, timelines, mentions, followers and Lists, against a 7-day search in the X node.
• Account safety: Sorsa API never asks for your X login or cookies, so no X account of yours is at risk.
• Reliability: in production since 2022 with 6B+ requests served; when X changes something, Sorsa API fixes it on its side and your workflow keeps the same fields.

#Give an n8n AI Agent live X data

An n8n AI Agent can search X on its own when Sorsa API is attached to it as a tool. Attach an HTTP Request node to the agent as a tool, point it at POST /search-tweets with your Header Auth credential, and fill the query body value with an expression that calls $fromAI('query', 'An X search query with operators', 'string'). The model then writes the search itself, and n8n sends it.

Under the tool's Optimize Response option, keep only full_text, user.username, created_at and likes_count, so the model reads posts instead of whole profiles and spends fewer tokens. The n8n guide to $fromAI() (opens in a new tab) covers the parameters. For agents outside n8n, such as Claude or Cursor, see the Twitter API for AI agents.

#Build your first X workflow in n8n

Reading X data in n8n comes down to one HTTP Request node with a key header, the right endpoint and a cursor that pages until it is empty. Build it on Sorsa API: one ApiKey header 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.

The same node pattern works in code too; the Twitter API in Python guide shows it with requests.

#FAQ