Twitter API in n8n: Get X Data via HTTP Request (2026)

By Sorsa Editorial

Updated: June 2026. Refreshed for X's pay-per-use API pricing after the April 20, 2026 change, the current n8n X node operation set, and a verified HTTP Request pagination recipe.

Most n8n builders hit the same wall: the native X (Twitter) node was built to publish, not to read. It posts tweets, sends DMs, and runs a thin search, all metered through the official X API. The moment you want full timelines, follower lists, mentions, or anything historical at volume, you drop down to the HTTP Request node and point it at a data API. Sorsa API, a read-only Twitter/X API, is built for exactly that call: one key in an ApiKey header, flat per-request billing (one call is one request, author profiles included), a flat 20 requests per second on every plan, and no developer-account approval queue. Plans start at $49 per month for 10,000 requests, which works out to roughly 50 times cheaper per 1,000 tweets than the official API's per-resource read rate.

Contents

• Can n8n pull Twitter/X data, or does the node only post?
• Getting Twitter/X data into n8n without the official API
• Configure the HTTP Request node step by step
• Common n8n and X data workflows
• What it costs to pull X data in n8n in 2026
• FAQ

Can n8n pull Twitter/X data, or does the node only post?

n8n's built-in X node is write-focused. According to n8n's own documentation, the node creates direct messages and, for a tweet, supports delete, search, like, and retweet. There is no operation for follower lists, full timelines, mentions, quote tweets, or historical search, and the one search it offers runs on the paid official X API.

That is the gap that surprises people. The node is genuinely useful for publishing: schedule a tweet, auto-reply, retweet on a trigger. For reading public data, it does almost nothing, and what little it does is throttled and metered by X.

So the read path in n8n is the HTTP Request node. It is the universal connector for any REST API n8n does not ship a dedicated node for, and a Twitter data API is exactly that. You set the method, the endpoint URL, an auth header, and your parameters, and the JSON comes back into the workflow ready for a Filter, a Code node, or a Google Sheets write.

We build and run a read-only X API daily, and the division of labor is clean in practice: use the native node when the goal is to act on X (post, like, DM), and use the HTTP Request node when the goal is to pull data out of X (tweets, profiles, followers, search). The two coexist on the same canvas.

Getting Twitter/X data into n8n without the official API

You can read X data in n8n without the official X API by calling a third-party Twitter data API from the HTTP Request node. These services query public X data on their own infrastructure and hand back JSON, so an X developer account, OAuth, and app review are not required. The phrase "no API key" almost always means no X API key: the data provider still issues a key of its own.

That distinction matters, because the genuinely keyless options are the fragile ones.

Community scraper nodes. Packages like n8n-nodes-twitter-scraper exist, and they work through scraping under the hood. The catch is in their own docs: the node uses the Rettiwt library, whose "key" is auth derived from X's web interface, not the official API. In plain terms, it rides a logged-in session token, which can get the underlying account flagged and breaks whenever X changes its web internals. It also installs as a community node, which is off by default on n8n Cloud.

Apify actors. A common tutorial route wires an Apify Twitter actor to n8n through the HTTP Request node or the Apify node. It works and ships with rotating proxies, but it bills per item scraped and adds an actor-run orchestration layer (start run, wait for finish, fetch dataset) on top of your workflow.

A managed read-only API. The lowest-maintenance route is a hosted Twitter data API called directly from the HTTP Request node. Because it queries public data server-side, you never expose your own X login, which is the thing that gets accounts suspended with cookie-based scrapers. Sorsa is one such option: a single ApiKey header, no OAuth, no approval queue, and a setup that takes a couple of minutes. If your concern is specifically the developer-account barrier, that path is covered in depth in our guide to using the X data without a developer account.

Is reading public X data against the rules? Pulling public, non-logged-in data through a managed API is a different risk profile from automating your personal account with scraped session cookies. The managed API does the fetching; your n8n workflow only consumes JSON. For a wider view of the trade-offs, see our breakdown of the ways to scrape X data.

Configure the HTTP Request node step by step

Configuring the HTTP Request node for a Twitter data API comes down to four settings: the request method (GET or POST), the endpoint URL, an authentication header carrying the API key, and a body or query parameter for the username or search query. For results that span multiple pages, turn on the node's cursor pagination so it follows the response cursor automatically.

Set the method, URL, and ApiKey header

Different endpoints use different HTTP methods, and mixing them up is the most common first mistake. Profile and follower lookups are GET; tweet search and timelines are POST. Pass the key in a header named ApiKey (not as a Bearer token, and never in the URL). In n8n, store it as a Header Auth credential rather than hardcoding it, since credentials stay encrypted and reusable across nodes. The header format is documented in the authentication reference.

A GET lookup, which maps directly to a GET HTTP Request node:

curl -H "ApiKey: YOUR_API_KEY" \
  "https://api.sorsa.io/v3/info?username=nasa"

A POST search, which maps to a POST node with a JSON body:

curl -X POST "https://api.sorsa.io/v3/search-tweets" \
  -H "ApiKey: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "from:nasa moon", "order": "latest"}'

The search endpoint supports Twitter Advanced Search syntax inside query (from:, since:, until:, quoted phrases, hashtags). It has no limit parameter; page size is fixed and you walk results with the cursor. The full operator set is in our cheat sheet on advanced search operators.

Handle cursor pagination in n8n

Paginated endpoints return a next_cursor field; when it is null or absent, there are no more pages. n8n's HTTP Request node can follow this without a Code node. Open Options, enable Pagination, and set:

• Pagination Mode: Update a Parameter in Each Request
• Type: Body for POST endpoints (search, timelines), Query for GET endpoints (followers, following)
• Name: next_cursor
• Value (expression): {{ $response.body.next_cursor }}
• Pagination Complete When: Other (Complete Expression), set to {{ !$response.body.next_cursor }}

Add a short interval or a Wait node inside the loop so a long run stays under the rate limit. This pattern is described in n8n's HTTP Request pagination cookbook. If you prefer the manual version, an IF node that checks whether next_cursor exists and loops back works too, but the built-in pagination is cleaner for a clean JSON cursor like this one. The cursor contract on the data side is documented under pagination.

Store the results

Once the JSON is flowing, a Google Sheets node appends each tweet or profile as a row, and a Remove Duplicates node keeps a re-running workflow from logging the same record twice. The end-to-end version of that, from request to populated sheet, is walked through in exporting X data to Google Sheets.

Common n8n and X data workflows

These are the patterns that actually get built. Each is one HTTP Request node plus the storage of your choice.

Pull a user's tweets by username

POST /user-tweets returns a paginated timeline (about 20 tweets per page) for any public account. Feed a list of handles through a Loop Over Items node and you have a multi-account timeline collector.

Search tweets by keyword or query

POST /search-tweets runs a query with order set to popular or latest. This is the workhorse for topic monitoring, hashtag tracking, and dataset building.

Monitor brand mentions on a schedule

POST /mentions returns tweets mentioning a handle and adds filters the plain search lacks: min_likes, min_replies, min_retweets, since_date, and until_date. Pair it with a Schedule Trigger to run every few minutes. This is the core of a social listening setup, and the date filters keep low-value noise out of your database.

Extract follower and following lists

GET /followers, GET /follows, and GET /verified-followers each return up to 200 user profiles per request, one of the highest per-call yields available, which is what makes audience and lead workflows cheap to run. The mechanics are covered in our guide to the followers and following endpoints.

Enrich a list of profiles in bulk

GET /info-batch accepts up to 100 usernames or IDs and returns all their profiles in a single request, so a CRM enrichment step that would otherwise loop 100 times becomes one call.

Verify giveaway and campaign actions

POST /check-follow answers whether one account follows another; check-retweet and check-comment do the same for retweets and replies. Chain them in a workflow that validates entries against your own rules.

Track trends by location

GET /trends takes a WOEID (a location identifier) and returns the trending topics for that region, useful for a daily trend digest piped to Slack or email.

What it costs to pull X data in n8n in 2026

Cost is where the choice of backend actually decides the project. The official X API bills per resource fetched: every post and every profile in a response is a separate billable unit. A flat per-request API bills per call regardless of how many items come back. On the read-heavy, always-on workloads n8n is built for, those two models diverge fast.

X moved to pay-per-use as the default for new developers in February 2026, and the April 20, 2026 update reshaped the rates again. Post reads are $0.005 each, user reads $0.010 each, follower reads $0.010 each, there is no free tier, and pay-per-use accounts are capped at 2 million post reads a month. Standard post creation rose to $0.015, posts containing a URL jumped to $0.20, and follow, like, and quote-post writes moved to Enterprise-only. Many older guides still quote the retired "$100 to $200 Basic" subscription tiers; those are closed to new signups. The current, full breakdown lives in our 2026 Twitter API pricing guide.

Here is the same data through n8n's two practical backends. The official X API is the one the native node already uses; the flat alternative is what the HTTP Request node calls.

The takeaway in one line: for a read-only n8n workflow, the official API charges for every tweet and every profile separately, while a flat per-request API charges one unit per call with the author data included, so the flat model is both cheaper and more predictable on read-heavy automations.

If your workflow needs to post, send DMs, or run follow, like, or quote actions, that is the official API's territory, and Sorsa is read-only by design. For reading public data at a flat, predictable price with no approval queue, the request-based model is the one to anchor on. Full Sorsa pricing starts at $49 per month for 10,000 requests.

Most n8n scraping tutorials wire up a per-item-metered backend instead, such as twitterapi.io (about $0.15 per 1,000 tweets and $0.18 per 1,000 profiles) or an Apify Twitter actor (around $0.40 per 1,000 tweets, varying by actor). Both bill for every item returned, so a 24/7 Schedule Trigger that re-pulls the same accounts every few minutes can run up an unpredictable tab. A flat per-request model behaves differently: one call counts as one request whether it returns 1 item or 200, and the batch endpoints fold up to 100 tweets or 100 profiles into a single request. Where you can replace a loop with a batch or a 200-profile follower page, the request count, and the bill, drops sharply. The tactics for that are in our notes on optimizing API usage.

A real cost pattern

Across the social-listening setups we have helped move off the official API, the same shape recurs. One example: a small analytics agency, roughly eight people, ran a 24/7 brand-mention monitor in n8n that polled a set of accounts and search terms every few minutes. On the official X API's per-resource pricing, that volume (well over a million post reads a month once replies and quotes were counted) pointed at a four-figure monthly bill and sat close to the 2 million post-read cap. Re-pointing the same HTTP Request nodes at a flat per-request plan put the entire monitor inside a fixed monthly cost, and the mention endpoint's min_likes and date filters trimmed the noise before it ever reached their database.

FAQ

Is the n8n X (Twitter) node deprecated?

The n8n X (Twitter) node is not deprecated and still runs, but it is write-focused, and its older OAuth 1.0a authentication was retired with the V2 node. It creates DMs and lets you delete, search, like, or retweet a tweet through the official X API. To read public data at scale, n8n builders use the HTTP Request node with a data API instead.

Does n8n have a built-in Twitter scraper?

No, n8n has no built-in Twitter or X scraper. The native X node publishes and runs a shallow search on the paid official API, and community scraper nodes rely on logged-in session tokens that break often. The standard approach is the HTTP Request node calling a read-only Twitter data API that returns tweets, profiles, and followers as clean JSON.

Can you read tweets and post tweets with the same n8n setup?

Yes, but they are two different connections. The native X node handles posting, DMs, likes, and retweets through the official X API, while reading tweets, followers, and mentions at volume runs through the HTTP Request node pointed at a data API. Many workflows combine both: read with one, publish with the other, on the same canvas.

Is there a free way to get X data in n8n?

There is no reliable free way to pull X data at volume in n8n. The official X API dropped its free tier in 2023, public Nitter instances are unstable, and community scraper nodes ride logged-in session cookies that risk account suspension. Low-cost managed data APIs with their own key are the dependable route, usually a few dollars for thousands of records.

How do you avoid rate limits when pulling X data in n8n?

To avoid rate limits in n8n, space requests with a Wait node inside pagination loops and pick a data API with a simple, generous limit. Sorsa applies a flat 20 requests per second on every plan, with no per-endpoint windows or 15-minute resets, so a workflow can page through followers or search results without tripping a quota mid-run.

Can you pull old or historical tweets in n8n?

Yes. The HTTP Request node can fetch historical tweets in n8n when the data API exposes archive search. Sorsa's search and user-tweets endpoints reach the full public tweet archive back to 2006, with since_date and until_date filters on the mentions endpoint for date-bound pulls, so you can backfill a dataset instead of only collecting tweets going forward.

Getting started

Reading X data in n8n comes down to two nodes and one key. Add an HTTP Request node, set the ApiKey header, point it at the endpoint you need, and turn on cursor pagination. A Sorsa API key takes about three minutes to set up with no developer-account review, the flat 20 requests per second leaves room to page through large lists, and pricing starts at $49 per month for 10,000 requests. If you run Make or Zapier instead of n8n, the same data API drops into those tools the same way: see the Make version and the Zapier version.

Reviewed by Keksich, founder of Sorsa, marketer and X API researcher.

This guide draws on our team's hands-on work running a read-only X API in production and on the live endpoints documented at docs.sorsa.io. The n8n behavior was checked against n8n's official X node documentation and its HTTP Request pagination docs; the X API rates reflect X's developer platform pricing current after the April 20, 2026 update. The comparison weighs the official X API and Sorsa across nine dimensions. Verified June 17, 2026.