TwitterAPI.io vs SocialData: price per item, limits, monitoring and how to switch

How each one bills

Both services bill per item returned, which makes them easier to compare than flat per-call providers: the question is simply what one item costs, and what happens at the edges, when a request returns nothing.

SocialData charges, according to its pricing page (docs.socialdata.tools/getting-started/pricing), “$0.0002 per tweet or user profile returned (or $0.2 per 1000 items)” on most endpoints: search, user tweets, mentions, followers, verified followers, following, comments, quotes, retweeters, threads, list and community tweets, and profiles in batches of up to 100. A few endpoints are priced per request: a single profile, a single tweet, list, community, Space and article details at $0.0002, the extended bio at $0.001, and the three social-action checks (did a user follow, retweet or reply) at $0.004 to $0.008. Requests that fail on its side are not billed. You prepay a balance; there are no plans.

TwitterAPI.io uses credits: 100,000 credits are $1. Tweets cost 15 credits each on search, timelines, replies, quotes, mentions, list and community tweets and tweets by ID alike, with a 15-credit minimum per request and no per-request cap. Profiles cost 18 credits each; profiles in bulk, followers and follower IDs get cheaper per item the more one request returns. The formula is:

request = max(15, 15 × tweets returned) credits · user search = 18 per user

Per tweet the difference is fixed: $0.00015 here, $0.0002 there, 25% lower here at every page size, so a full page is $0.003 against $0.004. Subscriptions lower our per-credit price: $1 buys 1.22× the credits on Builder and 1.9× on Business, counting the first-month bonus plus 12 monthly returns, so a full page is $0.0025 on Builder and $0.0016 on Business.

Price per data type

Because both bill per item, the difference on each endpoint comes down to page size and volume pricing. This table prices each kind of data the way you would actually fetch it. Green marks the lower price on that row.

Items per page: SocialData's search reference (docs.socialdata.tools/reference/get-search-results) says Twitter typically returns about 20 results per page, and its batch endpoints take up to 100 IDs. TwitterAPI.io returns up to 20 tweets per search or timeline page, up to 200 followers and 20 verified followers per page, and up to 5,000 follower IDs. TwitterAPI.io prices are from our pricing page and API reference; SocialData prices from its pricing page (docs.socialdata.tools/getting-started/pricing) and monitoring pricing (docs.socialdata.tools/monitoring/pricing), checked in 2026.

What a month costs: nine workloads

Rate cards only matter once they meet a workload. These are nine common jobs, each costed on both services with the arithmetic shown, so you can swap in your own numbers.

Thirty keyword alerts, each polled every 60 seconds

1,296,000 checks a month; 90% find nothing, 10% find 3 tweets (30 requests a minute, inside its 120 limit)

TwitterAPI.io30 × (38,880 × $0.00015 + 4,320 × $0.00045) = $233.28

SocialData1,036,800 billable empty checks × $0.0002 + 388,800 tweets × $0.0002 = $285.12

Research backfill, 1 million tweets

50,000 full 20-tweet search pages

TwitterAPI.io50,000 × $0.003 = $150.00

SocialData1,000,000 × $0.0002 = $200.00

200 accounts, user timeline every hour

144,000 timeline calls, ~20 tweets each

TwitterAPI.io144,000 × $0.003 = $432.00

SocialData2,880,000 tweets × $0.0002 = $576.00

Same 200 accounts via search (from:handle, since_id)

144,000 searches, about 1 new tweet each

TwitterAPI.io144,000 × $0.00015 = $21.60

SocialData144,000 × $0.0002 = $28.80

Enrich 100,000 profiles

by user ID in batches of 100

TwitterAPI.io100,000 × $0.00001 = $1.00

SocialData100,000 × $0.0002 = $20.00

Hydrate 100,000 tweets by ID

IDs you already have, in batches

TwitterAPI.io100,000 × $0.00015 = $15.00

SocialData100,000 × $0.0002 = $20.00

Export 1 million followers

200 per page here

TwitterAPI.io5,000 pages × $0.002 = $10.00

SocialData1,000,000 × $0.0002 = $200.00

100,000 verified followers

20 per page here, billed per page

TwitterAPI.io5,000 pages × $0.00015 = $0.75

SocialData100,000 × $0.0002 = $20.00

Real-time feed of 50 fixed accounts

push delivery of new tweets

TwitterAPI.ioTwitter Stream Professional: $149.00

SocialData50 user monitors × ~$4.49 = ~$224.50

Anything that moves real volume costs less on TwitterAPI.io: by about 1.3 times on search backfills, timelines and tweets by ID (25% lower per tweet), and 20 times or more on profiles in bulk, followers and verified followers.

Polling and keyword monitoring at volume

Above 12 checks a minute, polling costs less on TwitterAPI.io whatever share of checks comes back empty: an empty check is $0.00015 here against $0.0002 per billable empty check there, and each tweet found is $0.00015 against $0.0002. The thirty-alert workload above shows it at scale: $233.28 a month here against $285.12.

SocialData's rate limit is 120 requests a minute in total, so one account can run at most 120 one-minute polls. Its hosted search monitors are billed separately: its monitoring pricing (docs.socialdata.tools/monitoring/pricing) charges $0.0002 for every execution that delivers nothing, which at the default 30-second refresh is a floor of about $17.28 a month per query. Our keyword filter rules charge $0.00015 for an empty check ($12.96 a month at the same refresh) and $0.00015 per matched tweet against $0.0002, so a filter rule costs less per query than a search monitor at any match rate.

Poll accounts for new posts at the minimum price

Timelines already cost less here than on SocialData ($0.003 against $0.004 for a 20-tweet page), but most timeline polling is really asking “has this account posted anything new?”. A timeline call answers by returning the latest 20 tweets, and you pay for all of them. Asked as a search, the question only returns what is new. A query like from:nasa since_id:<last id> costs $0.00015 when nothing is new and $0.0003 for two new tweets, 15 credits per tweet it returns.

import os, time, requests

KEY = os.environ["TWITTERAPI_IO_KEY"]
HANDLES = ["nasa", "spacex", "esa"]  # accounts to watch
since = {h: None for h in HANDLES}

def check(handle):
    # the first run (no since_id yet) returns up to 20 recent tweets
    q = f"from:{handle}" + (f" since_id:{since[handle]}" if since[handle] else "")
    for _ in range(5):
        r = requests.get("https://api.twitterapi.io/twitter/tweet/advanced_search",
                         headers={"X-API-Key": KEY},
                         params={"query": q, "queryType": "Latest"}, timeout=30)
        if r.status_code == 429:
            # unpaid accounts are limited to 1 request every 5 s: wait, retry this account
            time.sleep(float(r.headers.get("Retry-After", 5)))
            continue
        break
    r.raise_for_status()
    tweets = r.json().get("tweets", [])
    if tweets:
        since[handle] = max(tweets, key=lambda t: int(t["id"]))["id"]
    return tweets  # 0 new tweets costs $0.00015; each new tweet $0.00015

while True:
    for h in HANDLES:
        try:
            for t in check(h):
                print(h, t["id"], t["text"][:80])
        except requests.RequestException as e:
            print("skipped", h, e)  # network error or 5xx: retry next round
    time.sleep(3600)  # hourly; 3 accounts x 720 checks = 2,160 checks a month

Every new tweet a check finds costs $0.00015 here against $0.0002 on SocialData, so the 200-account workload in the table above (about one new tweet per check) comes to $21.60 a month here against $28.80. Test the delay before relying on search for alerts measured in seconds: search results can arrive a little later than the timeline.

Features and limits

SocialData figures from its home page and FAQ (socialdata.tools), pricing (docs.socialdata.tools/getting-started/pricing), rate limits (docs.socialdata.tools/getting-started/rate-limits), API overview (docs.socialdata.tools/getting-started/overview), monitoring (docs.socialdata.tools/monitoring/introduction), MCP (docs.socialdata.tools/mcp/introduction) and fulfillment policy (socialdata.tools/legal/fulfillment-policy) pages; TwitterAPI.io from our pricing, rate limits, Twitter Stream, MCP server and refund policy pages. Checked in 2026.

Rate limits in practice

SocialData's rate-limit page (docs.socialdata.tools/getting-started/rate-limits) gives every account 120 requests a minute, shared across all endpoints, and offers higher limits “at no extra charge” if your app generates significant volume; over the limit you get a 429 and its errors page (docs.socialdata.tools/getting-started/errors) recommends exponential backoff. TwitterAPI.io allows 0.2 requests a second before the first payment, 20 after it (1,200 a minute), 50 on the Scale plan and 500 on Business, higher on request, and returns 429 with a Retry-After header. Your normal load may never notice the difference; a backfill will. Fetching 1 million tweets as 50,000 full search pages takes about 7 hours at 120 a minute and about 42 minutes at 20 a second.

Endpoint coverage

Most read endpoints exist on both: search with the full Twitter operator syntax, profiles (single and in batches), user tweets, mentions, followers, following, verified followers, replies, quotes, retweeters, threads, articles, list members and tweets, community details, members and tweets, and Spaces. TwitterAPI.io also has endpoints SocialData does not offer:

• Trends (/twitter/trends)
• Follower IDs only, up to 5,000 per page (/twitter/user/followers_ids)
• List followers; community moderators
• Write actions: post, reply, like, retweet, follow, DM, media upload
• Keyword filter rules pushed by webhook or WebSocket

Real-time delivery

Both push data instead of making you poll, in different shapes. SocialData's Monitoring API (docs.socialdata.tools/monitoring/introduction) creates one monitor per account and event type (new tweets, new follows, profile changes) or per search query, and sends each event as its own signed webhook. Its docs state: “We do not promise real-time delivery”; a user monitor delivers an event up to 30 seconds after it happens. User monitors are billed by the hour per monitor. TwitterAPI.io's Twitter Stream is a monthly plan for a list of accounts and delivers 80% of tweets in under a second; keyword filter rules run on our side and push matches by webhook or WebSocket, billed like polling the search yourself.

SocialData monthly figures are its own estimates per monitor, from its monitoring pricing (docs.socialdata.tools/monitoring/pricing). From 18 accounts up Twitter Stream costs less: by about a third at 50 ($149 against about $224.50) and about 3.5 times less at 500, with most tweets delivered in under a second.

AI agents and MCP

SocialData runs a hosted MCP server (docs.socialdata.tools/mcp/introduction) at its API address, authenticated with the same Bearer key and billed like the REST calls; it notes that the claude.ai and ChatGPT connector interfaces cannot use it because they need OAuth. TwitterAPI.io's MCP server covers search, users, followers, replies and trends, open source under the MIT license and run as an npx package. Both are read-only. The cost difference follows the REST prices: an agent paging through followers pays $0.20 per 1,000 there and $0.01 here, and an agent running searches pays $0.003 for a full page here against $0.004 there.

Write actions

SocialData is read-only: it does not post, like or follow, and has no X account connection. TwitterAPI.io has write endpoints (post, reply, like, retweet, follow, DM, media upload) that take login cookies from its login endpoint plus a proxy. If you need both reading and posting from one provider, only TwitterAPI.io covers it; either way, keep automated actions on an X account human-paced.

The same request on both

The paths and field names differ more than between most providers, because SocialData returns Twitter v1.1-style objects and puts user IDs in the path. A search is still one GET on each:

# TwitterAPI.io
curl -H "X-API-Key: $TWITTERAPI_IO_KEY" \
  "https://api.twitterapi.io/twitter/tweet/advanced_search?query=from%3Anasa&queryType=Latest"

# SocialData
curl -H "Authorization: Bearer $SOCIALDATA_KEY" -H "Accept: application/json" \
  "https://api.socialdata.tools/twitter/search?query=from%3Anasa&type=Latest"

SocialData request and response fields from its search (docs.socialdata.tools/reference/get-search-results), followers (docs.socialdata.tools/reference/get-user-followers), authentication (docs.socialdata.tools/getting-started/authentication) and errors (docs.socialdata.tools/getting-started/errors) pages. Compare the full objects for every endpoint you use before moving production traffic.

One adapter for either provider

If you want to run both, or keep the option to move, put the differences in one place. This TypeScript generator pages through a search on either service, maps each tweet to one shape, backs off and retries on 429, and stops with a clear error on SocialData's 402 (balance empty):

// One client, either provider. Base URL, auth header, search path,
// sort parameter, end-of-results rule and tweet fields differ.
type Provider = "twitterapi.io" | "socialdata"

type Tweet = { id: string; text: string; createdAt: string; likes: number; author: string }

const CONFIG = {
  "twitterapi.io": {
    url: (q: URLSearchParams) => `https://api.twitterapi.io/twitter/tweet/advanced_search?${q}`,
    headers: (key: string) => ({ "X-API-Key": key }),
    params: (query: string) => ({ query, queryType: "Latest" }),
    hasMore: (body: any) => Boolean(body.has_next_page),
    toTweet: (t: any): Tweet => ({ id: t.id, text: t.text, createdAt: t.createdAt, likes: t.likeCount, author: t.author?.userName }),
  },
  socialdata: {
    url: (q: URLSearchParams) => `https://api.socialdata.tools/twitter/search?${q}`,
    headers: (key: string) => ({ Authorization: `Bearer ${key}`, Accept: "application/json" }),
    params: (query: string) => ({ query, type: "Latest" }),
    hasMore: (body: any) => (body.tweets ?? []).length > 0, // no separate flag: stop on an empty page
    toTweet: (t: any): Tweet => ({ id: t.id_str, text: t.full_text ?? t.text, createdAt: t.tweet_created_at, likes: t.favorite_count, author: t.user?.screen_name }),
  },
} as const

const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))

export async function* searchTweets(provider: Provider, key: string, query: string, maxPages = 10) {
  const c = CONFIG[provider]
  let cursor = ""
  for (let page = 0; page < maxPages; page++) {
    const params = new URLSearchParams(c.params(query))
    if (cursor) params.set("cursor", cursor)
    let res: Response
    for (let attempt = 0; ; attempt++) {
      res = await fetch(c.url(params), { headers: c.headers(key) })
      if (res.status !== 429 || attempt === 5) break
      // Retry-After when present, otherwise exponential backoff
      const wait = Number(res.headers.get("retry-after"))
      await sleep(wait > 0 ? wait * 1000 : 1000 * 2 ** attempt)
    }
    if (res.status === 402) throw new Error(`${provider}: balance empty, top up`)
    if (!res.ok) throw new Error(`${provider} ${res.status}`)
    const body = await res.json()
    for (const t of body.tweets ?? []) yield c.toTweet(t)
    if (!c.hasMore(body) || !body.next_cursor) return
    cursor = body.next_cursor
  }
}

Switching checklist

1. List the endpoints you call and how often. Price the list with the table above; most bills are two or three endpoints.
2. Measure your real items per request and how many checks you run per minute; above 12 checks a minute polling costs less here whatever share comes back empty.
3. Count the accounts you watch and decide how much delay you can accept: from 18 accounts up, or for sub-second alerts, Twitter Stream costs less and delivers faster.
4. Replace user-ID path parameters with query parameters, and map the snake_case tweet fields to camelCase (or use the adapter above).
5. Replace one-by-one profile lookups with /twitter/user/batch_info_by_ids in batches of 100 or more, and use /twitter/user/followers_ids if you only need IDs.
6. Load-test with your real backfill. On TwitterAPI.io make a first payment first (unpaid accounts are limited to 0.2 requests a second); on SocialData ask support for a higher limit before you need it.
7. Run both in parallel for a few days and compare bills and row counts before cutting over. TwitterAPI.io's signup credit covers a test without a card.

Price your own workload

The calculator from our Twitter API price comparison, with SocialData highlighted. Enter how many searches you run, how many tweets they usually return and the request rate you need. It prices every SocialData item at $0.0002 and counts every empty response there as free, so for polling above 3 empty checks a minute it understates SocialData's bill. If most of your checks come back empty (low-frequency polling), compare the per-check price for your volume; on the Business plan an empty check costs $0.000079 after 12 monthly payments ($0.0001 in the first month). For the full rate cards see Twitter API pricing.

Is TwitterAPI.io legit? What our public pages state

People comparing API providers reasonably ask who is behind them. These are the facts TwitterAPI.io publishes about itself, each with the page it comes from.

SocialData publishes the equivalent on its side: its home page states it is an independent third-party service not affiliated with X Corp., its status page (status.socialdata.tools) reports service uptime, and its fulfillment policy (socialdata.tools/legal/fulfillment-policy) sets out the 14-day refund. Whichever you choose, the simplest due diligence is the same: start on a small balance, check the bill against your own request log, and keep the refund window in mind.

Both against the official X API

Both services exist because of what the official API costs. X now bills per resource read with no subscriptions: according to its pricing documentation, $0.005 per post read, $0.010 per user read and $0.010 per follower or following read; creating a post costs $0.015, or $0.20 if it contains a URL. Pay-per-use is capped at 3 million post reads per monthly billing cycle, above which you need an Enterprise agreement. New accounts get $20 of credits when they save a first eligible card, plus a match of the first auto-recharge up to $50.

The official API still makes sense when you need a contract with X, posting through X's own consent screen, or data that only an authenticated first-party app can read. For profiles and follower lists the gap is wider: 1,000 user reads are $10 officially, $0.20 on SocialData and $0.01 here in bulk. See TwitterAPI.io vs the official X API for the full comparison.

Quick decision guide