Reddit API Access in 2026: How to Get Started

You can still get Reddit API access as an individual builder: register an app, accept the Data API Terms, and state plainly what you'll do with the data, whether that's a small script or a workflow built in a tool like Activepieces.

The Reddit API is Reddit's OAuth-based interface for reading and writing posts and comments.

Reddit API access is the process of registering an app with Reddit, agreeing to its Data API Terms, and authenticating with OAuth so your code can read or write Reddit content within set rate limits and approval rules.

You can fetch listings, search, read comment trees, submit posts and comments, and perform moderation actions, all scoped by the permissions your app requests.

Ask only for scopes you use. A reviewer scanning your request will click yes faster on read than on a pile of write scopes.

Getting access to the Reddit API

Free access versus commercial use

At $549 million, advertising still carries the business, according to Reddit's Q3 2025 results. The "Other" line, which includes data licensing, was $36 million, about 6% of the $585 million total.

Because data licensing is small but deliberate, Reddit isn't hunting for hobbyists to bill. It does draw a firm line between personal or non-commercial use and anything that makes money from its content.

If your tool charges users, you're on the commercial side of that line, and you should plan for a conversation with Reddit rather than a form.

Registration and approval requirements

You register at reddit.com/prefs/apps, under the "create another app" button. You fill in a name and pick a type (script, web app, or installed app).

**If your tool charges users, you're on the commercial side of that line, and you should plan for a conversation with Reddit rather than a form.

Then add a description and a redirect URI. That description is the field a reviewer is most likely to read, so write what the app does, what data it touches, and how often.

Before you write code, not after, request access through the Data API documentation and read the Data API Terms. Whatever you build on, whether custom scripts or a no-code tool, the same registration and terms apply.

Read the approval column first, because it decides how much lead time you need. The table shows which route fits which kind of builder.

Who	Access route	Terms that apply	Approval needed	As checked 1 Nov 2026
Individual builder	Register an app at reddit.com/prefs/apps, authenticate with OAuth	Data API Terms	Yes, state your use case	Route described in developer docs
Researcher	Same app registration, with the research purpose stated	Data API Terms	Yes, expect closer review	Terms page covers non-commercial use
Moderator tool developer	App registration, acting through moderator permissions	Data API Terms	Yes, tied to the subreddits you serve	Moderator scopes listed in the API docs
Commercial app	Direct agreement with Reddit	Data API Terms plus commercial terms	Yes, negotiated	Outside the free path

Since every row needs approval, design the request first and the code second.

App registration and first authenticated request

Three stages get you from nothing to a JSON response, and each one leaves you with something you can check before moving on.

The approver will read the request you described in the previous step, so keep that description open while you fill in the form. The app you register should match what you said it'd do.

Stage 1: create the app and copy credentials

Sign in to the Reddit account that'll own the app, open the apps page in your account preferences, and click the button to create another app. The form asks for a name, an app type, a description, an about URL, and a redirect URI.

Pick the type deliberately. Choose "script" if only you'll run it against your own account. Choose "web app" if other people will authorize it, and "installed app" if it ships as a client that can't keep a secret.

The type decides which OAuth flows you can use later, so changing your mind means re-registering.

Even for a script, the redirect URI is required. For a local script, a localhost address works, so long as it's a valid URL you control.

If you name the app "test2", a reviewer learns nothing, and they won't click through to find out. Name the app for what it does.

Save the form. The credentials screen shows your client ID as the short string under the app name and the line "personal use script" or the app type. The secret is the field labeled "secret".

Copy both into environment variables, not into source files, so the first commit doesn't leak them. You now have a registered app and two values.

Stage 2: request an access token

Send a POST to Reddit's token endpoint at https://www.reddit.com/api/v1/access_token. Authenticate with HTTP basic auth: your client ID is the username and your secret is the password.

For a script app, the body carries grant_type=password along with the account's username and password. For an app acting for other users, you use the authorization code flow instead, and the redirect URI from Stage 1 receives the code.

Set a User-Agent on this request too. Default library agents are the first thing Reddit throttles.

When it works, the response is a JSON object holding an access_token and a token_type of bearer. If you see an error instead, check the client ID and secret first, since swapping them is the usual cause.

Store the token in memory and note when it expires, so your code refreshes it instead of failing mid-run.

Calling a Reddit API endpoint with a User-Agent

Now call https://oauth.reddit.com, not www.reddit.com, because authenticated traffic goes to the oauth host. Add two headers: Authorization: bearer <your token> and a User-Agent in the form Reddit's rules ask for, such as linux:myapp:v0.1 (by /u/yourname).

Try /api/v1/me first. It needs no special approval, and it returns your account as JSON, which shows the request is set up correctly.

If that response comes back with your username in it, you have a working, authenticated client. Everything after this is a different endpoint on the same pattern, so the design work now moves to how often you call it.

Reddit API rate limits and pricing

You get 100 requests per minute per client ID on free OAuth access, and the sources behind these figures publish no per-unit price. So the budget is a fixed ceiling you design under, not a meter you pay by.

Limits by access type

Two access types matter first. ApixStar reports that unauthenticated calls get 10 queries per minute and have been blocked since 30 May 2026, while a free OAuth app gets 100 per minute per client ID.

Skipping registration isn't a cheaper path, because unauthenticated access is unconfirmed.

Below the OAuth ceiling sit the other routes, per ApixStar's rate-limit guide:

Route	Requests per minute	What it means for you
OAuth client	100	Your working budget for reads
Account endpoints	30	Anything touching a user's account gets under a third of that
No OAuth	Blocked	Not usable, since it is blocked
Feedback endpoints	10	Fine for occasional reports, never for a loop

If 50 people use your app, all 50 draw from the same 100, because usage is counted per client ID, not per user.

At that scale you get about two requests per person per minute, so any inefficiency in system design quickly exhausts the budget.

Cache responses and batch work before launch, not after the first 429.

Reading Reddit API rate-limit headers

Open any response and look for three fields: X-Ratelimit-Used, X-Ratelimit-Remaining and X-Ratelimit-Reset. Used is what you've spent in the current window, Remaining is what's left, and Reset is the seconds until the window rolls over.

Build your client to read Remaining on every call and sleep until Reset when it nears zero. Don't wait for an error to tell you.

A reviewer checking your app will look at whether it backs off on its own. A visible backoff is a better argument for approval than a paragraph in your application saying you'll "respect limits."

What Reddit publishes about pricing

There is no per-unit price in the sources behind these figures, for the free tier or for commercial access, and I won't invent one.

Treat the 100 requests per minute as free, capped and tied to your registered client ID, which means requests exceeding this limit will be rejected.

If your use is commercial, expect the terms to be settled with Reddit directly, not read off a rate card.

Plan around that gap. Don't put a cost-per-call into your business model until Reddit gives you a number in writing. The ApixStar figures here were checked on 1 November 2026, so re-check them against Reddit's own pages before you commit to a design.

Common Reddit API errors and fixes

You can fix all of the usual production failures in code, and five causes account for most of them. They are an expired token, a blocked app, a missed rate limit, a missing User-Agent, or content you were required to delete.

Fixing Reddit API 401 and 403 errors

When an access token expires, you get a 401. Reddit's tokens last one hour, so any job that runs longer, or a worker that caches a token at startup, will fail on schedule.

Store the expiry time next to the token, refresh before it lapses, and retry the failed call once with the new token. If the refresh itself returns 401, check the client ID and secret on your registered app.

A 403 is different: refreshing won't help. Either your app lacks the scope for that endpoint, or the app or account is blocked.

Check the scopes you requested first, then the app's status in your Reddit account. Community reports say a blocked app often comes with no explanation, so treat that as unconfirmed and ask Reddit through its support channel.

Handling Reddit API 429 rate-limit errors

When you've used up your request window, you get a 429. Read the rate-limit reset header on the response and sleep until it elapses, rather than guessing at an interval.

A fixed sleep of your own either wastes time or hits the wall again, and repeated hits are what get an app flagged.

For 5xx errors, which are Reddit's fault rather than yours, retry on a short schedule.

Look at the Apollo backend, a third-party Reddit client's open-source code, which waits 200 ms, then 500 ms, then 1000 ms, then 2000 ms. That's a community pattern, not a Reddit-published figure.

It means four retries cost about 3.7 seconds in total, short enough for a user waiting on a screen.

If the fourth retry fails, stop and surface the error, because more retries only add load to a service that's already struggling.

User-Agent and terms violations

Set the User-Agent once in your HTTP client and stop thinking about it. Send a descriptive one on every request, naming your app and version, plus your Reddit username. Community reports describe generic or missing agents being throttled harder or rejected.

No retry will fix a violation of the Data API Terms, because Reddit handles those, not your code.

Reddit API deleted content and data retention

If you store posts or comments, you must also remove them when the author deletes them on Reddit.

Build a periodic job that re-checks stored items and purges any that are gone. Design this at the start.

Retrofitting deletion onto a database with no record of where each item came from is slow, and it's the duty an approver is most likely to ask about.

Calling the Reddit API without code in Activepieces

You can run scheduled or event-driven Reddit work without a script on a server you host: describe the job to the Activepieces built-in chat and it publishes a live flow in your account, no different from one a builder wired up by hand.

Open that flow's run trace and it records what each step did, including which Reddit calls went out, so you or an approver can read exactly what happened with no code to read.

Access control and audit logs apply to it as they do to any flow. MoneyGram, Moneypenny, Alan and FundingSocieties run Activepieces in production, and free-plan flows are unlimited, so a daily Reddit pull costs you nothing in flow count.

Nothing about registration, the Data API Terms, or approval changes because a canvas sits in front, or because the chat built the flow; it makes the same API calls, under the same OAuth credentials and the same limits, as code would.

The screenshot below is a "Test Flow" canvas with four steps: an "Every Day" Schedule trigger, a "Picks topic" Code action, an "SEO Keyword Sea..." HTTP request, and an "SEO blog writer" Agent action, which is selected so its configuration panel is open on the right; if any step fails, that day's content never publishes, meaning there's no error recovery or manual override option.

Take the shape from it: a trigger, a step that decides what to fetch, a request, then a step that uses the result.

The agent's prompt field refers to earlier steps by variable, so what you fetch in step three is what step four reads. A Reddit flow follows that same shape.

Using the Reddit connector

Activepieces has 746 integrations in its MIT-licensed open source monorepo, roughly 60% of them community-contributed. Where its Reddit integration (its name for a prebuilt connector) covers the action you need, use it, because it saves you hand-building requests and authentication.

You connect it with the credentials from the app you already registered, and every call it makes counts against that app's rate limit.

Check which triggers and actions the integration lists in the step picker before you plan around it; if the one you need isn't there, the next option covers it.

Because the connector acts as your registered app, the approver's questions still apply to you. A flow that runs daily and stores what it fetches has the same deletion and retention duties described above.

Put a Code step or a stored record of each item's source in the flow from the start, so you can remove it later.

Calling other Reddit API endpoints with HTTP

For any endpoint the integration doesn't expose, add an HTTP request step, the same kind as step three in the canvas. Point it at the Reddit endpoint with the same OAuth token.

You set the method, URL, headers, and a descriptive User-Agent yourself, so the responsibility for following Reddit's rules sits with you, not the tool.

Handle rate-limit responses in the flow: add a delay or a retry path rather than letting a scheduled run hammer the endpoint.

Reach for code when you need to track rate-limit headers across many calls, page through large result sets, keep state between runs, or write deletion logic that touches a database.

For a single scheduled pull or a reaction to one event, a canvas works well. Once the flow needs loops, bookkeeping, and error handling to stay inside the limits, a small script is easier to read, test, and defend to an approver.

Frequently asked questions

Four questions stay open after the body. Each is either tied to a Reddit page or marked unconfirmed, so you know which answers to build on and which to re-check before you ship.

Unauthenticated access is unconfirmed, because I found no Reddit page that promises it'll keep working, so design as if every request needs credentials. Review time is unconfirmed, since only community reports exist and Reddit publishes no turnaround.

Public price is cited as free for qualifying non-commercial use in Reddit's developer documentation, with commercial terms left to a separate agreement. AI training use is cited, because the Data API Terms restrict it without Reddit's permission.

Check each against the live pages before you rely on it; they change.

Is the Reddit API free to use?

Free for qualifying non-commercial use, according to Reddit's developer documentation, but I have no confirmed public price list beyond that. If your project earns money or serves paying users, assume you'll need a separate commercial arrangement with Reddit.

Budget for that conversation before you build, not after the first invoice-shaped email.

Can I use Reddit data for AI training or commercial products?

Not by default. The Data API Terms restrict using Reddit content to train machine learning models without Reddit's express permission, and commercial products fall under a different arrangement than the free tier.

Whatever you plan, say it plainly in the app description. If the approver reads "personal research tool" and your pipeline feeds a model, you have a compliance problem that no rate-limit handling will fix.

Do I need approval before I can create an app?

Plan on registering the app and describing your use, and treat approval as a gate you pass before real traffic. The review time is unconfirmed; community reports exist, but Reddit doesn't publish one.

Write the use-case field so a reviewer can say yes in one read: what you pull, how often, where it goes, and what you delete. A vague description invites a vague no, or silence.

Can I scrape Reddit instead of using the API?

I wouldn't build on scraping, because Reddit's terms don't treat it as an equivalent substitute. Automated collection outside the API sidesteps the registration, rate limits, and content rules that the Data API Terms exist to enforce.

An account or IP block is a realistic outcome, and it leaves you with no standing to appeal.

If the API route is too restrictive for your idea, that's a reason to ask Reddit or narrow the idea, not to route around the gate.

Related reading

• Best Tools for Citizen Developers in 2026

References

• Apollo backend (GitHub)
• ApixStar
• Reddit Inc.