Search public tweets, get profiles and followers, and track engagement through one REST API. All endpoints included. Start with 100 free requests.
100 free requests · No credit card · No expiry
{"query": "AI agents min_faves:100", "order": "latest"}
{ "tweets": [ { "id": "1782368585664626774", "full_text": "The future of AI agents is multi-modal...", "created_at": "2026-04-28T14:30:00Z", "likes_count": 2847, "retweet_count": 891, "reply_count": 42, "user": { "username": "techfounder", "verified": true } } ], "next_cursor": "eyJhbGciOiJIUzI1..." }
Run real requests in the playground, track your usage, and manage your API keys — all from one dashboard.
Choose an endpoint, enter your parameters, and inspect the JSON response. No code required.
Try API for Free
Check your remaining balance, track request volume over time, and see usage by API key.
Try API for Free
Access and manage the API keys you use to connect your applications to Sorsa.
Try API for Free
Every endpoint explained in plain language, with copy-paste examples in cURL, Python, and JavaScript. Plus an LLM-ready version for AI agents.
Read the DocsLower data costs. One simple request rate across every endpoint.
Start with 100 free requests.
| Feature | Sorsa API | Official X API | Competitors |
|---|---|---|---|
| Cost per 1K tweets | From $0.02 | $5.00 | $0.15 |
| Cost per 1K profiles | From $0.02 | $10.00 | From $0.10 |
| Free trial | 100 free requests | No free trial | $0.10 in credits |
| Rate limit | 20 req/s | ~0.3 req/s | Varies |
| Latency (p50) | 300ms | ~1s | 500ms |
| AI-ready docs | Yes | No | Partial |
| Pricing model | Flat: 1 req = 1 call | Pay-per-resource | Credits |
| Payment methods | Cards & crypto | Card only | Varies |
Use the API reference, MCP server or Sorsa skill in a compatible development workflow.
Give your coding assistant the API documentation URL to help write your integration.
Connect a compatible MCP client using your Sorsa API key. Follow the setup instructions for your client.
Example launch command $npx sorsa-mcp Set up the MCP serverUse the Sorsa API skill in a supported agent environment. See the repository for setup and requirements.
Get the skill on GitHubPOST /v3/search-tweets import os, requests key = os.environ["SORSA_API_KEY"] r = requests.post( "https://api.sorsa.io/v3/search-tweets", headers={"ApiKey": key}, json={"query": "AI agents min_faves:100"}, ) print(r.json())
Search, profiles, followers, timelines and verification. Choose an endpoint for your task and inspect its request and response fields.
/v3/search-tweets/v3/check-retweet/v3/tweet-info-bulkEstimate the Sorsa API requests your workload needs, then check the available plans.
The same volume runs about $1,000,000 a month on the official X API. A custom Sorsa plan is a small fraction of that, with a lower per-request price, a higher dedicated rate limit beyond 20 per second, and a dedicated account manager.
Talk to salesCreate your account, copy your Sorsa API key and try a request in the language you use.
curl "https://api.sorsa.io/v3/info?username=example_user" \ -H "ApiKey: YOUR_API_KEY"
import requests profile = requests.get( "https://api.sorsa.io/v3/info", headers={"ApiKey": "YOUR_API_KEY"}, params={"username": "example_user"} ).json()
const res = await fetch( "https://api.sorsa.io/v3/info?username=example_user", { headers: { "ApiKey": "YOUR_API_KEY" } } ); const profile = await res.json();
package main import "net/http" func main() { req, _ := http.NewRequest("GET", "https://api.sorsa.io/v3/info?username=example_user", nil) req.Header.Set("ApiKey", "YOUR_API_KEY") http.DefaultClient.Do(req) }
$ch = curl_init("https://api.sorsa.io/v3/info?username=example_user"); curl_setopt_array($ch, [ CURLOPT_HTTPHEADER => ["ApiKey: YOUR_API_KEY"], CURLOPT_RETURNTRANSFER => true ]); $profile = json_decode(curl_exec($ch), true);
{ "id": "1900000000000000001", "username": "example_user", "display_name": "Example account", "followers_count": 1200, "followings_count": 85 }
A maintained X (Twitter) data API with clean JSON, stable response schemas, and cursor-based pagination. We handle platform updates so you can focus on your application.
The same speed on every plan.
Public status page with live updates.
Edge-cached responses.
Search, profiles, followers, and verification.
From trading signals to giveaway verification: how developers integrate X (Twitter) data with predictable pricing and straightforward setup.
A trading pipeline monitors X for ticker mentions around the clock. Rate limits on the official X API interrupted polling during volatility spikes, while two other providers struggled under load. Moving to Sorsa gave the pipeline a consistent 20 req/sec limit for ongoing market monitoring.
A solo-built giveaway platform used the official X API to verify follows, retweets, and comments until projected costs exceeded monthly revenue. The developer moved those checks to Sorsa’s dedicated verification endpoints in one weekend. Flat per-request pricing brought the platform’s unit economics back into positive territory.
An AI team used Claude and Sorsa’s API documentation to port its existing X data client. The model handled about 90% of the migration on the first pass; the remaining work was renaming two fields. Stable response schemas and consistent JSON let the team work straight from the documentation, with no support tickets and no sandbox approval process. Connecting to Sorsa required only a signup and an API key.
Explore practical uses for search, profile data and verification.
Compare public account metrics, posting activity and follower data across competing accounts.
/info/followers/user-tweetsTrack brand mentions and keyword conversations with supported search queries and filters.
/search-tweets/mentionsSearch posts for ticker and company mentions, then aggregate results for your own analysis.
/search-tweets/trendsResearch public business profiles and relevant conversations to assess fit for your product.
/search-tweets/infoConfirm follows, reposts, replies and community membership with a single call per check.
/check-follow/check-retweetDate-filtered search and tweet-ID lookup for research. Free or discounted access for eligible institutions.
/search-tweets/tweet-info-bulkFlat plans, no credit math: 1 request = 1 unit on every endpoint. One request returns up to 100 tweets or 200 profiles, which is why the per-tweet price beats every pay-per-call API. Same 20 req/sec on all plans. Pay by card or crypto.
Sorsa API is a read-only REST API for public X (Twitter) data. It covers 41 endpoints across user profiles, posts, advanced search, followers and following, Lists, X Articles, Spaces, trends, and action verification, and returns clean JSON. On your side, a single Sorsa API key is the whole setup, with no X developer-account application. Pricing is flat per request, from $0.02 per 1,000 tweets, and every new account starts with 100 free requests. Sorsa has run in production since 2022, first as TweetScout API.
No. The only credential you need is a Sorsa API key, issued instantly when you sign up. You do not file an X developer application, complete an OAuth flow, or wait in an approval queue, and you never share your own X login or cookies with Sorsa. Create an account, copy the key from the dashboard, pass it in the ApiKey header, and your first request works within minutes.
Sorsa API returns public X data: user profiles (one at a time or 100 per batch), followers and following lists (200 per page), posts by ID (100 per batch), full user timelines, replies, quote posts, retweeters, keyword and mention search with the full advanced-search operator set, Lists, X Articles, Spaces, trends by location, account About data such as based-in country, and verification checks that confirm whether a user followed, retweeted, quoted, or replied. Out of scope: protected accounts, DMs, who liked a post, a user’s likes or bookmarks, deleted posts, and any write action such as posting, liking, following, or messaging. Sorsa is read-only by design. The full endpoint list is in the API reference.
Sorsa bills per request; the official X API bills per resource. On X, every post, profile, and follower in a response is a separate charge, about $5.00 per 1,000 post reads plus $10.00 for their authors’ profiles, and reads are capped at 2 million posts a month. On Sorsa, one request returns up to 100 tweets or 200 profiles with author data included, so 1,000 tweets cost from $0.02, up to 50x cheaper on read-heavy work. On your side, a single Sorsa API key replaces OAuth and a developer application. The trade-off is that Sorsa is read-only: posting, DMs, and other write actions stay with the official API. For a step-by-step switch, see the migration guide.
Three ways. Pricing is flat per request rather than metered per item, and batch endpoints return up to 100 tweets or 200 profiles in one request, which is how Sorsa reaches $0.02 per 1,000 tweets where per-item APIs typically charge several times more. Coverage includes what many alternatives skip: follow, retweet, quote, and reply verification, X Articles, Spaces, and account About data such as based-in country. And Sorsa is a managed service: the response schema stays stable, and when X ships changes to its platform the fix happens on our side, not in your codebase.
Yes. Every request is served live when you call it, so follower counts, engagement metrics, and search results reflect X at that moment rather than a cached copy. Median response time is about 300 ms. Sorsa does not provide a streaming firehose or webhooks; real-time monitoring works by polling at up to 20 requests per second, which every plan includes. The one exception is the shadowban check, whose result is cached for one hour per handle.
To an account’s first post. User timelines paginate through the entire posting history with no 3,200-tweet cap, and search accepts since: and until: operators back to 2006, so you can pull old posts for any keyword, hashtag, or account. Engagement counts come back as they stand at request time. Follower and following lists reflect the current graph; Sorsa does not store historical snapshots of who followed whom. For methods and code, see the guide to historical X data.
20 requests per second on every plan, Starter through Enterprise, with all endpoints included and no throttling on lower tiers. Since one request can return up to 100 tweets or 200 profiles, that is up to 2,000 tweets or 4,000 profiles per second before pagination. Plans differ only in monthly volume: 10,000, 100,000, or 500,000 requests. Custom plans above that come with a higher dedicated rate limit; contact sales to set one up.
Nothing on your side. When X ships changes to its platform, the Sorsa team handles the update, the response schema stays the same, and your integration keeps running without code changes. That is the practical difference between a maintained service and a DIY script or open-source library that you have to fix yourself after every X update. Sorsa has run in production since 2022, and the public status page shows live uptime and latency.
No. Sorsa is an independent service and is not affiliated with, endorsed by, or sponsored by X Corp; X and the X logo are trademarks of X Corp. You access public X data through Sorsa’s own API, dashboard, and Terms of Service, and you remain responsible for using, storing, and sharing that data in line with the laws that apply to you and your project, including any privacy rules that cover the people whose posts you process. Nothing on this page is legal advice.
Any language that can send an HTTP request. Sorsa API is plain REST: put your key in the ApiKey header, send JSON, get JSON back, no SDK required. Guides cover Python, Node.js, Go, PHP, n8n, Make, and Zapier. For AI-assisted builds, paste the single documentation URL into Claude Code, Cursor, ChatGPT, or Codex and let the model write the client, or install the sorsa-mcp server from npm to give Claude and other MCP clients live X data directly. Most integrations, including migrations from the official X API, take under two hours.
From $0.02 per 1,000 tweets and $0.01 per 1,000 profiles on flat plans, where one API call always counts as one request on every endpoint. Every new account starts with 100 free requests, enough for up to 10,000 tweets or 20,000 profiles, with no card and no expiry. Paid plans run from 10,000 to 500,000 requests a month, billed monthly or yearly (yearly saves 16 percent), payable by card or crypto, and can be cancelled at any time. Full plan details and a cost calculator are on the pricing page.
Support runs through tickets: open one in your dashboard and the team answers there, with full documentation and a public status page alongside it. From 1M requests a month you can request a personal account manager who handles your questions faster. Uptime has held at 99.9% since 2022 with no major production outages, and median latency is about 300 ms. When X ships changes to its platform, the fix lands on Sorsa’s side, so most teams rarely need to open a ticket at all.
More questions? Write to contacts@sorsa.io or open a support ticket in your dashboard once you sign up.
Create an account, run a request and inspect the response. Your first 100 requests are free, with no credit card and no expiry.
Get free API key