Twitter API Without a Developer Account: 6 Ways (2026)

By Sorsa Editorial

Published June 13, 2026. Updated September 23, 2026: rebuilt around six routes that need no X developer account, with a 2026 status check of unofficial Twitter APIs, the X archive route, updated official pay-per-use rates, and a five-minute API key quickstart. Official X API rates verified September 2026.

The fastest of those routes takes minutes. Sorsa API, a read-only Twitter/X data API, returns public profiles, posts, search results, and follower lists as JSON behind a single ApiKey header, and you don't need an X account or an X developer account to get a key. Billing is flat per request with the author profile included in every post, which works out to about $0.02 per 1,000 tweets on batch endpoints on the Pro plan (from $0.049 on Starter). 100 free requests, no card and no expiry, cover a first real pull.

This guide compares all six routes on setup, reliability, and cost, checks which unofficial Twitter APIs still work in 2026, and ends with working code you can run today.

Contents

• Can you use the Twitter API without a developer account?
• What the official X API requires in 2026
• 6 ways to get X data without a developer account
• Which unofficial Twitter APIs still work in 2026?
• Can you post or run a bot without a developer account?
• What does X data cost without a developer account?
• How to get X data with an API key in five minutes
• Worked example: a research sprint without a developer account
• What to check before you collect X data
• FAQ
• Getting started

Can you use the Twitter API without a developer account?

Not the official one. Every call to the X API needs credentials from a developer app, and that app lives inside a developer account tied to an X account with prepaid credits. Public X data is a different story: profiles, posts, search results, and follower lists can be read without a developer account through a third-party API that issues its own keys, free browser tools, your own X archive, public datasets, or open-source libraries.

Which route fits depends on what you need. For your own account's history, the archive is free. For a one-off lookup, a browser tool is enough. For live data inside an app, a dashboard, or an AI agent, an API key is the route built for production: documented endpoints, one header, and predictable billing.

What the official X API requires in 2026

The official path still runs through X's Developer Console:

1. Sign in at console.x.com with an X account and accept the Developer Agreement.
2. Create an app, which generates your API key, secret, and access tokens.
3. Buy credits upfront. Calls draw down the balance and stop when it runs out, unless auto-recharge is on.
4. Handle OAuth: a bearer token for app-only reads, OAuth 2.0 or OAuth 1.0a for anything done on behalf of a user.

What changed in 2026 is the billing. X moved to pay-per-use on February 6, 2026, and new developers get no free read allowance. Reading other accounts' data costs $0.005 per post and $0.010 per profile or follower, per X's pricing page, and post reads are capped at 3 million per billing cycle. Legacy Basic plans moved onto the same meter after June 1, 2026, legacy Pro plans are following after September 1, and follow, like, and quote-post endpoints left self-serve plans on April 20, 2026. Rate limits still apply on top, mostly in 15-minute windows per endpoint.

None of this is hard for a funded product team. It is heavy for a researcher on a deadline, a founder testing an idea, or an AI agent that needs a few thousand posts, which is why most people searching for a way around the developer account only want to read public data. The step-by-step official route is in the guide to getting an X API key, and every official line item is in the X API pricing breakdown. If you already run on the official API and want out, the X API changes and migration guide maps every endpoint.

6 ways to get X data without a developer account

1. A third-party data API with an API key

A provider runs documented REST endpoints and you call them with a key. You skip the app review, the OAuth flow, and the credit balance on X's side, and your own X accounts stay out of it. This is the route for production work: dashboards, monitoring, research pipelines, lead lists, and AI agents. Sorsa covers profiles, timelines, search with advanced operators, followers and following, replies, quotes, reposters, lists, trends, and Spaces, all read-only, with one request billed per call whatever it returns. The quickstart below gets a first response in about five minutes.

2. Free browser tools, no key at all

For a single answer, a key is overkill. The free X tools on Sorsa run common lookups in the browser without an API key: shadowban checks, recent followers, follow checks, account age, account location, engagement rate, and username to ID conversion. They are the quickest way to answer one question about one account.

3. Your own X archive

If the data you need is your own, X will hand it over. In settings, open Your account, choose Download an archive of your data, verify your identity, and request it. The archive covers your posts, DMs, followers, following, lists, and media, and X's help page notes it may take a few days to prepare. It only covers your account, and it is a one-time snapshot rather than a feed.

4. Public datasets and ID rehydration

Kaggle, Hugging Face, and academic repositories host large tweet collections that are well suited to historical analysis and model training. Two limits apply: they are frozen at collection time, and many ship as post IDs only, so the text has to be looked up again (rehydrated) before it exists in your copy. A bulk endpoint turns 100 IDs into full posts per request, as the guide to building a Twitter dataset for machine learning shows.

5. Open-source unofficial libraries

Libraries such as twscrape and twikit call X's internal web endpoints from your own code. They are free and flexible, but they log in with real X accounts, need fixes whenever X changes its site, and put those accounts at risk of restriction. They suit experiments more than products. The status table in the next section shows which ones still run.

6. Browser automation and no-code scrapers

Playwright, Selenium, and point-and-click scraping tools read X the way a browser does. They can capture anything visible on screen, but X shows little content to logged-out visitors, pages load slowly, and layouts change often, so upkeep grows with every week in production. The comparison of Twitter scrapers in 2026 covers the managed and no-code options with real per-1,000 costs.

Which unofficial Twitter APIs still work in 2026?

"Unofficial Twitter API" usually means an open-source library or front end that reads X through its internal web endpoints instead of the developer platform. Most of the well-known names are gone. Here is where they stand in September 2026:

Of the five, only twscrape is both working and maintained, and it runs on your own logged-in X accounts, which carry the risk if X restricts them. That trade is fine for a weekend experiment and hard to justify in production, where most teams use a documented third-party data API with its own keys instead. For a wider market view, see Twitter API alternatives compared.

Can you post or run a bot without a developer account?

Reading and writing are separate problems. Reading public data without a developer account is well supported. Writing acts on behalf of an account, and the sanctioned way to do it programmatically is X's official API under OAuth.

There are two sanctioned options. You can authorize a scheduling or posting service that runs its own X developer app, so you connect your account through OAuth instead of creating a developer account yourself. Or you create the developer account and pay for writes directly: $0.015 per post and $0.20 per post with a link. Follows, likes, and quote-posts are no longer available on self-serve plans at all. Libraries that post through X's internal endpoints with a logged-in session exist, but they put that account at risk. Read-only data APIs such as Sorsa do not post, reply, or send DMs, so the common setup for a bot is a read API for everything the bot watches plus a small official balance for what it publishes.

What does X data cost without a developer account?

For read-heavy work, key-based access is far cheaper than the official meter. X bills every post and profile a response returns; a flat per-request API bills the call. Sorsa runs from $0.02 per 1,000 tweets through its bulk endpoint, about $0.10 per 1,000 tweets through paginated search on the Pro plan, and from $0.01 per 1,000 profiles through follower lists, which makes read-heavy workloads up to 50x cheaper than per-resource billing.

Sorsa figures use Pro plan rates and full pages. At a few thousand posts a month the official meter costs $10 to $25, and the gap opens quickly as volume grows. To price your own mix of posts, profiles, and followers, run it through the X API cost calculator. If the question is simply whether any of this is free, the answer, route by route, is in is the Twitter API free.

How to get X data with an API key in five minutes

Three steps: create a key, make a call, page through results.

1. Get a key. Sign up in the Sorsa dashboard with any available sign-in option. You don't need an X account, a developer app, or a card, and the first 100 requests are free.

2. Make a first call. A profile lookup is one GET request with one header:

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

3. Search and paginate. Search is a POST with a JSON body, takes X's advanced search operators such as from:, since:, min_faves:, and filter:media, and returns about 20 posts per page with the author embedded in each one:

import os
import requests

API = "https://api.sorsa.io/v3"
HEADERS = {"ApiKey": os.environ["SORSA_API_KEY"]}

r = requests.post(
    f"{API}/search-tweets",
    headers=HEADERS,
    json={"query": "from:nasa filter:media min_faves:500", "order": "latest"},
    timeout=30,
)
r.raise_for_status()
page = r.json()
for t in page["tweets"]:
    print(t["created_at"], t["user"]["username"], t["likes_count"], t["full_text"][:80])

next_cursor = page.get("next_cursor")  # send it back in the body for the next page

Follower lists work the same way with GET and return up to 200 full profiles per request:

def get_followers(username, limit=1_000):
    """Collect up to `limit` follower profiles, 200 per request."""
    users, cursor = [], None
    while len(users) < limit:
        params = {"username": username}
        if cursor:
            params["next_cursor"] = cursor
        r = requests.get(f"{API}/followers", headers=HEADERS, params=params, timeout=30)
        r.raise_for_status()
        data = r.json()
        users.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
    return users[:limit]

for u in get_followers("nasa", limit=400):
    print(u["username"], u["followers_count"], u["created_at"])

# Requests left on your key
print(requests.get(f"{API}/key-usage-info", headers=HEADERS, timeout=30).json())

Every endpoint shares the same header and a flat limit of 20 requests per second. For a full Python walkthrough, including timelines and exports, see the Twitter API Python guide, and for follower graphs at scale, the followers and following lists guide. To try endpoints without writing code first, the API playground sends real requests from the browser.

Worked example: a research sprint without a developer account

Consider a researcher who needs, within a month, 400,000 posts on a topic, the follower lists of 60 accounts (about 300,000 follower records), and 5,000 profiles for accounts that keep coming up.

On the official API, the work starts with an X account, a developer app, and a prepaid balance. The reads then cost:

• 400,000 posts at $0.005: $2,000
• 300,000 follower records at $0.010: $3,000
• 5,000 profiles at $0.010: $50

That is about $5,050, and it uses 400,000 of the month's 3 million post reads.

With an API key, the same pull is 20,000 search requests at 20 posts each, 1,500 follower requests at 200 each, and 50 batch requests at 100 profiles each: 21,550 requests in total, inside the 100,000-request Pro plan at $199 a month. The 100 free requests come first, which is enough to test every query on real data before paying anything. Faculty, postdocs, PhD and master's students, and civil-society researchers on non-commercial projects can also apply for free or discounted academic access.

What to check before you collect X data

A key makes collection easy, so the checks belong at the start:

• Stick to public data. Leave protected accounts and direct messages out of any collection.
• Collect only what the question needs, and store personal data under the privacy rules that apply to you, such as GDPR or CCPA.
• Share IDs, not full text, if you publish a dataset, and let others rehydrate it.
• Keep write actions on the official API.
• Know who you are dealing with. Sorsa is an independent service and is not affiliated with or endorsed by X Corp. You are responsible for making sure your use of the data complies with applicable laws and any terms that apply to you.

FAQ

Can you use the Twitter API without a developer account?

Not the official X API, which needs a developer app, an X account, and prepaid credits. Public X data can still be read without a developer account through a third-party API that issues its own keys, free browser tools, your own X archive, public datasets, or open-source libraries. A key-based API such as Sorsa is the most practical of these for live data at volume.

Do you still need a developer account for the X API in 2026?

Yes. You sign in at console.x.com with an X account, accept the Developer Agreement, create an app for credentials, and buy credits before the first call. Since February 6, 2026 reads are billed per resource, at $0.005 per post and $0.010 per profile, with post reads capped at 3 million per billing cycle and no free read allowance for new developers.

Is the Twitter API public?

The X API is publicly documented, and anyone with an X account can sign up, but it is not open: every call needs developer credentials and prepaid credits. Public X data itself can be read without a developer account through third-party APIs that issue their own keys, such as Sorsa, which returns profiles, posts, search results, and followers as JSON.

Is there a free way to get Twitter data without a developer account?

Yes, for small jobs. Your own X archive is free, public datasets are usually free, and free browser tools handle one-off lookups. For programmatic access, Sorsa gives every new account 100 free requests with no card and no expiry, enough for up to 2,000 posts through search or 20,000 follower profiles. The official X API no longer offers new developers any free reads.

What is an unofficial Twitter API?

The term usually means an open-source library or front end, such as twscrape, twikit, or the former Nitter, that reads X through its internal web endpoints instead of the developer platform. These tools are free but depend on logged-in X accounts and frequent fixes. For production work, most teams use a documented third-party data API with its own keys, such as Sorsa, instead.

Which unofficial Twitter APIs still work in 2026?

Very few. snscrape and Twint stopped working by 2023, Nitter went offline after X's cease-and-desist letters in August 2026 and a brief September revival, and twikit's latest release has been reported broken since March 2026. twscrape is maintained and works, but only with your own logged-in X accounts, which carry the risk if X restricts them. For production work, a documented third-party data API is the usual choice.

Can you post tweets or run a bot without a developer account?

The sanctioned way to post programmatically is X's official API. You can avoid creating your own developer account by authorizing a scheduling or posting service that runs its own X app. Libraries that post with a logged-in session exist but put that account at risk. Read-only data APIs such as Sorsa do not post, reply, or send DMs, so bots usually pair a read API with a small official balance for writes.

Do you need an X account to use Sorsa?

No. You sign up for a Sorsa API key without an X account or an X developer account, and the first 100 requests are free with no card. Every request uses one ApiKey header and returns public X data as JSON, with flat per-request billing from about $0.02 per 1,000 tweets on batch endpoints.

How much does X data cost without a developer account?

It depends on the route. Archives, datasets, and browser tools are free. Through a flat per-request API such as Sorsa, reads run from about $0.02 per 1,000 tweets and $0.01 per 1,000 follower profiles on the Pro plan. The official X API charges $5 per 1,000 posts and $10 per 1,000 profiles, so read-heavy work is up to 50x cheaper through a key.

Getting started

For a one-off question, open the free X tools and get the answer in the browser. For anything you plan to run more than once, a key is the shortest path: get an API key, paste the curl call above, and you have JSON in minutes. The 100 free requests are one-time, need no card, and never expire, which covers up to 10,000 tweets through the bulk endpoint or 20,000 follower profiles while you test.

When you are ready to scale, the flat per-request pricing plans run from about $0.02 per 1,000 tweets on batch endpoints, with 20 requests per second on every plan. If the data feeds an AI assistant or agent, the same data is available through the Sorsa MCP server.

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

This guide draws on our team's hands-on work running the live Sorsa API since 2022. The official developer-account steps, pay-per-use rates, and the 3 million post-read cap were checked on September 23, 2026 against X's Developer Console documentation and pricing page, and the archive steps against X's Help Center. The status of snscrape, Twint, Nitter, twikit, and twscrape was checked against their GitHub repositories, package releases, and reporting on X's 2026 cease-and-desist letters to Nitter. Sorsa endpoints and parameters were checked against the v3 API documentation, and the code samples were tested against mocked API responses. Sorsa is an independent service and is not affiliated with or endorsed by X Corp. Verified September 2026.