X API vs Bridgly: an alternative to the official Twitter API

Updated

Bridgly is an alternative to the official X API for reading public X data. It charges 1 credit per tweet, profile or follower, which is $0.002 on pay-as-you-go and $0.0017 on Scale, where X charges $0.005 per post and $0.010 per user, and it needs one API key instead of a developer app. The official X API is still the right choice for posting, DMs, streaming, full-archive search and first-party compliance.

Try Bridgly with 100 free credits, no card required. See the X (Twitter) API and view pricing.

X now bills every read. Its developer platform moved to pay-per-usage pricing, so each post, profile and follower record your app pulls is deducted from a prepaid balance. That makes the per-resource price the number to compare, along with setup time and what each API covers. We build Bridgly, so it is the second column below. Every X price and limit on this page comes from X’s own developer documentation, checked on November 7, 2026.

X API vs Bridgly at a glance

What mattersBridglyOfficial X API
Tweet read1 credit: $0.002 pay-as-you-go, $0.0017 on Scale.$0.005 per post.
Profile or follower record1 credit each, same price as a tweet.$0.010 per user and per follower or following record.
Setup before the first callSign up and create an API key. No X account or developer app.Developer account, accepted Developer Agreement, an app, and saved keys and tokens.
Read coverage12 X endpoints: search, profiles, timelines, replies, media, followers, following, retweeters and quotes.Posts, users, Spaces, DMs, lists, trends and more.
Writes (post, like, follow, DM)Not currently covered. Bridgly reads public data.Yes, priced per request.
Real-time deliveryPoll search with withinHours for new tweets.Filtered stream and webhook events.
Search historyX search syntax, including date operators.Recent search (7 days) and full-archive search back to 2006.
Repeat readsOpt-in cached results cost no credits.Same resource is charged once per UTC day.
Free start100 credits at signup, no card.None. You buy credits before the first call.
Volume ceilingNo cap on total reads. Rate limits rise with purchase size.3 million post reads per billing cycle, then Enterprise.
Same key for other social platformsYes, one balance across every platform.X only.

What each read costs

X prices reads per resource returned, and users cost twice as much as posts. Bridgly bills tweets, profiles and follower records at the same 1 credit, and some calls are flat: a tweet with its first page of replies and a profile lookup cost 1 credit per request. A Bridgly credit costs $0.002 on pay-as-you-go and $0.0017 with a single Scale purchase of $300 or more.

ResourceOfficial X APIBridgly, pay-as-you-goBridgly, Scale
Tweet from search or a timeline$0.005$0.002$0.0017
User profile$0.010$0.002$0.0017
Follower or following record$0.010$0.002$0.0017
Retweeter (returned as a user)$0.010$0.002$0.0017
Your own posts, followers and likes$0.001 (owned reads)$0.002$0.0017

The last row is X’s lowest price. Owned reads cost $0.001 per resource, less than a Bridgly credit on any self-serve package, including Scale ($0.0017). They only apply when an app reads the account that owns the developer app: its own posts, mentions, followers and likes. Most products read other accounts, such as search results, competitors, customers or creators, and those reads are billed at X’s full $0.005 and $0.010 rates.

The cost of common X data jobs

The table prices the same jobs on both APIs at each one’s published per-resource rate. Tweets are priced as post reads and accounts as user reads. Prices are USD, as of November 7, 2026.

WorkloadOfficial X APIBridgly, pay-as-you-goBridgly, Scale
Search 10,000 tweets$50.00$20.00$16.67
Monitor a keyword for 30 days (300 new tweets a day)$45.00$18.00$15.00
Look up 1,000 profiles$10.00$2.00$1.67
List 50,000 followers of one account$500.00$100.00$83.33
Launch amplifier workflow below (301 tweets, 600 accounts)$7.51$1.80$1.50

Two things narrow the gap in practice. X charges a resource once per UTC day, so reading the same post again that day is free. On Bridgly, a request can set cacheMaxAgeHours to accept a cached result up to that age, which costs no credits; without it, every call scrapes live. Follower-heavy jobs show the widest gap, because X charges $0.010 for each follower record while Bridgly charges 1 credit.

See the per-endpoint billing on the X (Twitter) API page, or start with 100 free credits and check creditsCost on your own queries.

Setup: developer app or one API key

The official route starts in the X Developer Console. You sign in with an X account, accept the Developer Agreement, describe your use case, create an app, and save an API key and secret, a bearer token, access tokens and OAuth 2.0 client credentials. The console shows those credentials only once. Reading public data needs the bearer token; acting for a user needs OAuth.

Bridgly needs a Bridgly account and an API key sent as a bearer header. There are no X credentials on your side, and the same key works over the REST API, the TypeScript SDK, the CLI and the MCP server.

Both work with AI agents. X’s hosted MCP server runs on your own developer app, through an app-only bearer token or a local OAuth bridge, and adds full-archive search, bookmarks, trends and Articles drafts. Bridgly’s MCP server is hosted at mcp.bridgly.app: Claude and ChatGPT connect by signing in, and other clients use the API key.

Search operators: what changes when you switch

Bridgly’s tweet search takes the query you would type in the X search box. The X API uses its own operator set, and X’s docs warn that the web-search names min_faves: and min_retweets: return a 400 error there. When you move a query from the X API to Bridgly, translate the few operators that differ:

FilterOfficial X APIBridgly (X search syntax)
Minimum likesmin_likes:100min_faves:100
Minimum repostsmin_reposts:50min_retweets:50
Has a linkhas:linksfilter:links
Author, recipient, languagefrom: to: lang:from: to: lang: (or the lang field)
Phrases, OR, exclusions"exact phrase" OR -wordSame
Time windowstart_time and end_time parameterssince: and until: in the query, or withinHours
Results per requestUp to 100 (recent) or 500 (full archive)Up to 20; send nextCursor back for more

Each Bridgly search result carries the text, author handle and verification, media, expanded links, and reply, retweet, like, quote, bookmark and view counts. Choose Latest for newest first or Top for X’s own ranking.

Endpoint map from the X API to Bridgly

Official X API v2Bridgly endpoint
GET /2/tweets/search/recent, /2/tweets/search/all`/x/search`
GET /2/tweets/:id, plus a conversation_id: search for replies`/x/get-tweet-detail` and `/x/get-tweet-replies`
GET /2/users/by/username/:username`/x/get-user`
GET /2/users/search`/x/search/users`
GET /2/users/:id/tweets`/x/get-user-tweets`, `/x/get-user-replies`, `/x/get-user-media`
GET /2/users/:id/followers, /following`/x/get-followers`, `/x/get-following`
GET /2/tweets/:id/retweeted_by`/x/get-tweet-retweeters`
GET /2/tweets/:id/quote_tweets`/x/get-tweet-quotes`
GET /2/users/:id/mentionsA search for @handle
Liking users, counts, trends, lists, Spaces, Communities, DMs, streams, writesNot currently covered

Timelines, followers, following, retweeters, quotes and replies take a numeric user or tweet ID, as on the X API. Get a user ID from the profile endpoint once and store it; it stays the same when the account changes its handle. Tweet endpoints also accept the tweet link.

Rate limits and page sizes

On X, rate limits are separate from billing. Each endpoint has its own cap per 15-minute window: recent search allows 450 requests per app, follower lists 300, and retweeters and quote tweets 75. Going over returns a 429 until the window resets.

Bridgly sets limits per platform and by purchase size: 2 requests per second and 30 per minute on pay-as-you-go, up to 25 per second and 1,000 per minute on Scale. A 429 comes with a Retry-After header, and rejected requests cost nothing. The TypeScript SDK handles this for you: it waits as long as the header asks and sends the request again, and with pagination: true it follows cursors until it has the count you asked for. X returns larger pages for search, so a search-only job makes fewer requests on X.

Example workflow: find who amplified a launch

This is the kind of job where per-user pricing adds up. The script finds an account’s most engaged tweet with a link this week, lists up to 500 retweeters and 100 quote tweets, looks up each quoter’s profile for a follower count, keeps the 10 largest accounts, and reads their last 20 tweets to see how often they cover the topic. The result is a short list of accounts worth contacting about the next launch.

TypeScript
import { Bridgly } from '@bridgly/sdk';
const client = new Bridgly({ apiKey: 'YOUR_BRIDGLY_API_KEY' });
type Amplifier = {
userId: string;
handle: string;
followers: number;
via: 'retweet' | 'quote';
};
/** The most engaged tweet with a link that an account posted this week. */
async function findLaunchTweet(handle: string) {
const result = await client.x.search({
query: `from:${handle} filter:links`,
sortOrder: 'Top',
withinHours: 168,
count: 1,
});
if (result.type === 'error') return null;
return result.data.tweets.at(0) ?? null;
}
/** Looks up a quote tweet author's profile to get their follower count. */
async function enrichQuoter(handle: string): Promise<Amplifier | null> {
const profile = await client.x.getUser({ handle });
if (profile.type === 'error') return null;
return {
userId: profile.data.userId,
handle: profile.data.username,
followers: profile.data.followerCount,
via: 'quote',
};
}
/** Everyone who retweeted the tweet, plus the authors of its quote tweets. */
async function listAmplifiers(tweetId: string): Promise<Amplifier[]> {
const [retweeters, quotes] = await Promise.all([
client.x.getTweetRetweeters({ tweetId, pagination: true, count: 500 }),
client.x.getTweetQuotes({ tweetId, pagination: true, count: 100 }),
]);
const fromRetweets: Amplifier[] =
retweeters.type === 'success'
? retweeters.data.users.map((user) => ({
userId: user.userId,
handle: user.username,
followers: user.followerCount,
via: 'retweet',
}))
: [];
const quoters = quotes.type === 'success' ? quotes.data.tweets : [];
const fromQuotes = await Promise.all(
quoters.map((tweet) => enrichQuoter(tweet.authorHandle)),
);
return [
...fromRetweets,
...fromQuotes.filter((amplifier) => amplifier != null),
];
}
/** How many of an account's latest tweets mention the topic. */
async function topicMentions({
userId,
topic,
}: {
userId: string;
topic: string;
}): Promise<number> {
const timeline = await client.x.getUserTweets({
userId,
pagination: true,
count: 20,
});
if (timeline.type === 'error') return 0;
return timeline.data.tweets.filter((tweet) =>
tweet.text.toLowerCase().includes(topic),
).length;
}
/** Ranks the large accounts that shared a launch by how often they cover the topic. */
async function rankAmplifiers({
handle,
topic,
}: {
handle: string;
topic: string;
}) {
const launch = await findLaunchTweet(handle);
if (launch == null) return [];
const amplifiers = await listAmplifiers(launch.id);
const largest = [...amplifiers]
.filter((amplifier) => amplifier.followers >= 10_000)
.sort((a, b) => b.followers - a.followers)
.slice(0, 10);
return Promise.all(
largest.map(async (amplifier) => ({
...amplifier,
topicMentions: await topicMentions({ userId: amplifier.userId, topic }),
})),
);
}
rankAmplifiers({ handle: 'vercel', topic: 'next.js' })
.then((ranked) => console.table(ranked))
.catch((error) => console.error(error));

With full results, the run reads 301 tweets (1 from search, 100 quotes and 200 from timelines) and 600 accounts (500 retweeters and 100 profiles). That is 901 credits on Bridgly, $1.80 on pay-as-you-go, and $7.51 at the X API’s per-resource rates. With pagination: true, the SDK follows nextCursor until it has the count you asked for, and creditsCost adds up every page.

When the official X API is the better choice

  • You need to write. Posting, replying, liking, following, bookmarks and DMs are only on the official API, which acts for a user through OAuth.
  • You need push delivery. Filtered stream and webhook events deliver matching posts as they are published, without polling.
  • You need guaranteed history. Full-archive search covers public posts back to March 2006, with up to 500 per request.
  • You need resources Bridgly does not cover today, such as liking users, post counts, trends, lists, Spaces or Communities.
  • You read only your own account. Owned reads cost $0.001 per resource, less than a Bridgly credit on any self-serve package.
  • Your contract requires first-party data. Some compliance teams accept only data received under X’s Developer Agreement.

When Bridgly is the better choice

  • Read-heavy products. Search, timelines and follower lists cost less per item, and user records cost the same as tweets.
  • Fast starts. One API key replaces the developer app, keys, tokens and OAuth setup.
  • Queries written for X search. Operators from the X search box work as typed.
  • More than X. The same key, SDK, MCP server and credit balance cover the other social platforms Bridgly supports.
  • Predictable spend. Every successful response returns creditsCost, errors cost nothing, and purchased credits never expire.

Moving an X API integration to Bridgly

  1. List the X API endpoints your app reads, and match each one in the endpoint map above.
  2. Translate search queries to X search syntax, mainly min_faves:, min_retweets: and filter:links.
  3. Swap the bearer token for a Bridgly API key and replace next_token paging with cursor and nextCursor, or set pagination: true in the SDK.
  4. Map the response fields you store. Bridgly returns each tweet with its engagement counts and author details already attached, so there are no fields or expansions to request.
  5. Keep writes, streams and other resources Bridgly does not cover on the official API. Both can run side by side.

Start with 100 free Bridgly credits, try tweet search, or contact the team to plan capacity for a large X workload.

Frequently asked questions

Is Bridgly the official X API?

No. Bridgly is an independent service, not affiliated with X Corp. It is an alternative for reading public X data without a developer app: you send a handle, user ID, tweet ID or search query with your Bridgly API key.

Is Bridgly cheaper than the X API?

For reading other accounts’ public data, yes. X charges $0.005 per post and $0.010 per user or follower record. Bridgly charges 1 credit for each, which is $0.002 on pay-as-you-go and $0.0017 on Scale. For the account that owns your developer app, X’s owned reads cost $0.001 per resource, which is less than a Bridgly credit on any self-serve package. Owned reads do not apply to any other account.

Can Bridgly post tweets or send DMs?

Not currently. Bridgly reads public data: tweets, profiles, timelines, replies, followers, retweeters and quotes. Use the official X API for posting, likes, follows and DMs.

Does Bridgly need an X developer account?

No. You need a Bridgly account and API key. There is no X developer app, OAuth flow or X login on your side.

Which search operators work on Bridgly?

The query is passed through in X search box syntax, so from:, to:, exact phrases, OR, exclusions, min_faves:, min_retweets:, filter:links and since:/until: all work. The X API names min_likes: and min_reposts: are its own; use the X search names on Bridgly.

Is there a cap on how much I can read?

X caps pay-per-usage accounts at 3 million post reads per billing cycle and moves larger users to Enterprise. Bridgly has no cap on total reads. It sets throughput with per-second and per-minute rate limits on each platform, which rise with purchase size.

Can I use both APIs together?

Yes. A common setup keeps posting, streams and owned reads on the official X API and moves search, profile, follower and engagement reads to Bridgly.

Related

Start pulling data in minutes.

100 free credits on business email, no card needed. Call any endpoint through the API, the TypeScript SDK or MCP.

APIMCPSDKCLI
free credits

On business email signup. No credit card required.

Start free