The Cheapest Reddit API for Developers

Posts, comments, search, users and communities as JSON — billed per call, with the whole ladder printed.

Try for Free See the Rate Card
5 endpoints Billed per call 10 Free API Calls No monthly plan

Search, user and community calls are one flat charge at any depth. A posts or comments listing is charged per started block of 25 items, and the whole ladder is on this page rather than on your first invoice.

Run a live subreddit listing

No signup and no key. The box sends a real /api/reddit/posts request and prints exactly what the endpoint returns.

We Charge for the Call. Most Reddit Vendors Charge for the Post.

That is the whole argument, and it is only honest if the items-per-call figure travels with it. So here it is on both sides.

What one call costs here

A search, user or subreddit call is $0.12 per 1,000 calls on Default, whatever depth you ask for. A search at limit=100 returns up to 100 results for that one charge — $0.0012 per 1,000 results.

A posts or comments listing is charged one unit per started block of 25 items. So 100 posts is four blocks, $0.48 per 1,000 calls, which works out at $0.0048 per 1,000 posts.

What the same 100 posts cost per item

Bright Data bills per record — one post or one comment — at $1.50 per 1,000 records. The prodiger Reddit actor on Apify bills per post, $1.15 per 1,000 at the free tier and $0.28 at its enterprise floor.

Read as a 100-post call, those are $150.00 and $115.00 per 1,000 calls, falling to $28.00 at that enterprise floor. Ours is $0.48. Per post the gap is 58× to 312×, and it is the reason this page exists.

The honest half of the same comparison. Per-call billing is not unique to us, and three rivals share our unit: redditapis.com at $2.00 per 1,000 read calls with up to 100 items in a call, SocialCrawl at about $2.70 per 1,000 calls on its Pro plan, and Decodo at $0.50 per 1,000 requests on entry, falling to $0.14 on a $99-a-month plan. We are below all three on a flat call and on a 25-post listing at $0.12, and below all three at limit=100 too, except one: Decodo’s $0.14 floor is cheaper than our $0.48 deepest listing call, and it is in the table for that reason. Every rate on this page was re-read on each vendor’s own pricing page on 2026-09-09; the full table is further down.

Five Reddit Endpoints, One API Key, One Rate

All five sit at the same $0.12 per 1,000 calls. Three are flat at any depth; the two paginated ones are charged per started block of 25 items.

Comments

Post comments

from $0.084
/1K calls at limit 25 (Scale)
  • GET /api/reddit/commentssubreddit + post_id
  • Author, body, score, depth, parent and permalink
  • Flat list, or nested replies[] with tree=true
  • Up to 100 comments per call; per started block of 25
Default$0.12/1K calls
Growth$0.108/1K calls
Scale$0.084/1K calls
How blocks are priced →
Search

Post search

from $0.084
/1K calls at any limit (Scale)
  • GET /api/reddit/searchq required, 512 chars
  • ID, title, author, subreddit, permalink, position
  • NSFW, spoiler and quarantined flags on every row
  • Up to 100 results for a single flat charge
Default$0.12/1K calls
Growth$0.108/1K calls
Scale$0.084/1K calls
Compare vendors →
User

User summary

from $0.084
/1K calls, flat (Scale)
  • GET /api/reddit/userusername required
  • Post karma, comment karma, cake day, avatar
  • Accepts name, u/name or @name
  • Summary only — no post or comment history
Default$0.12/1K calls
Growth$0.108/1K calls
Scale$0.084/1K calls
See the fields →
Subreddit

Community summary

from $0.084
/1K calls, flat (Scale)
  • GET /api/reddit/subredditname required
  • subreddit is accepted as an alias for name
  • Name, community ID and description
  • Weekly visitors and contributions, under their own names
Default$0.12/1K calls
Growth$0.108/1K calls
Scale$0.084/1K calls
See the fields →

The block ladder, in full — $0.12 is the price up to limit=25, not to limit=100

A posts or comments call is charged one unit per started block of 25 items. Nothing else on this API moves the price: sort, t and tree are free, and search, user and subreddit never leave one unit. Default rates below; Growth and Scale scale the whole ladder by the same 10% and 30%.

limit 1–25 (default)
$0.12
$0.0048 per 1,000 posts
limit 26–50
$0.24
$0.0048 per 1,000 posts
limit 51–75
$0.36
$0.0048 per 1,000 posts
limit 76–100 (sync cap)
$0.48
$0.0048 per 1,000 posts

Read that both ways. The deepest synchronous listing bills $0.48 per 1,000 calls — four times the headline $0.12, and that is printed first because it is the number that surprises people. Per post it never moves: $0.0048 per 1,000 posts at every full block, $0.0043 on Growth and $0.0034 on Scale. Depth here buys you fewer round trips, not a cheaper post.

A started block is charged whole, so limit=26 costs exactly what limit=50 costs. Ask for 26 posts and you have opened a second block and paid for it in full: $0.24 per 1,000 calls for 26 posts is $0.0092 per 1,000 posts, nearly double the ladder rate. Set limit on a 25 boundary — 25, 50, 75 or 100. It is the one parameter on this API that changes your invoice, and the only way to overpay on it is to miss the boundary by one.

Deeper than 100 items is the job form. Every one of the five operations has an asynchronous twin that holds no client socket, so it accepts up to 250 posts and up to 1,000 comments. It is priced on this same ladder — a 25-item job is never billed at the 1,000-item rate — and carries no bulk premium or multiplier of its own.

One call, one charge, up to 25 items a block. Growth is earned by a single $100 deposit and Scale by a single $500 deposit; both are one-time, the deposit is spendable balance rather than a fee, and a tier once earned never downgrades. A listing that genuinely comes back empty, or a community, post or account that is not there, is an answer and is charged; a failure on our side is refunded automatically. There is no monthly plan and no daily bucket anywhere in this pricing.

Reddit Data in One Request

One header, one GET, named JSON fields. Every key is always present, so an absent value arrives as null rather than as a missing key.

cURL — listing, comments, search
# A subreddit listing. limit=25 is the default and one block — the cheapest call here.
curl "https://apiserpent.com/api/reddit/posts?subreddit=python&sort=top&t=week&limit=25" \
  -H "X-API-Key: YOUR_API_KEY"

# One post's comments, nested. tree=true costs nothing extra; limit does.
curl "https://apiserpent.com/api/reddit/comments?subreddit=python&post_id=1m4k2ab&limit=100&tree=true" \
  -H "X-API-Key: YOUR_API_KEY"

# Post search. limit does NOT move the price here — 100 results for one charge.
curl "https://apiserpent.com/api/reddit/search?q=vector+database&limit=100" \
  -H "X-API-Key: YOUR_API_KEY"
Python — one listing into rows, on the block boundary
import os, requests

h = {"X-API-Key": os.environ["SERPENT_API_KEY"]}

# 50, not 40. A started block is charged whole, so 40 costs what 50 costs
# and returns ten fewer posts for the money.
p = {"subreddit": "python", "sort": "top", "t": "week", "limit": 50}

data = requests.get("https://apiserpent.com/api/reddit/posts",
                    params=p, headers=h, timeout=120).json()

# `delivery` is present ONLY when the call came back short. Read it before
# the rows: a short week and a cut-short request look identical in a chart.
if "delivery" in data:
    d = data["delivery"]
    print(d["returned"], "of", d["requested"], "—", d["reason"])

for post in data["posts"]:
    print(post["score"], post["num_comments"], post["title"])
Node — a community summary
const qs = new URLSearchParams({ name: "python" });

const res = await fetch(`https://apiserpent.com/api/reddit/subreddit?${qs}`, {
  headers: { "X-API-Key": process.env.SERPENT_API_KEY }
});

const { subreddit } = await res.json();
// weekly_visitors and weekly_contributions are what Reddit's own card states.
// They are NOT member counts and are never relabelled as any — a null here
// means the card did not state one, not that the number is zero.
console.log(subreddit.name, subreddit.weekly_visitors, subreddit.weekly_contributions);
JSON Response — /api/reddit/posts (one row of 25)
{
  "success": true,
  "subreddit": "python",
  "sort": "top",
  "count": 25,
  "posts": [
    {
      "id": "1m4k2ab",
      "fullname": "t3_1m4k2ab",
      "title": "What finally made type hints click for me",
      "author": "example_user",
      "author_id": "t2_9xk21",
      "subreddit": "python",
      "subreddit_id": "t5_2qh0y",
      "score": 1842,
      "upvote_ratio": 0.96,
      "num_comments": 214,
      "created_at": "2026-09-08T14:22:07.000Z",
      "permalink": "/r/python/comments/1m4k2ab/what_finally_made/",
      "domain": "self.python",
      "post_type": "text",
      "language": "en",
      "award_count": 3,
      "is_nsfw": false,
      "flair": { "text": "Discussion", "background_color": "#0079d3" },
      "stickied": false,
      "locked": false,
      "archived": false,
      "media": null,
      "thumbnail": null
    }
  ]
}
JSON Response — the delivery block, present only on a short call
{
  "success": true,
  "subreddit": "python",
  "count": 63,
  "posts": [ /* 63 rows */ ],
  "delivery": {
    "requested": 100,
    "returned": 63,
    "reason": "deadline_reached",
    "note": "Delivered the results gathered within this request.",
    "async_endpoint": "/api/reddit/posts/async"
  }
}

Read delivery before the rows. It appears only when the call came back short, and its reason separates the two situations a chart cannot tell apart: fewer_available means we walked to the end and that is genuinely all there was, deadline_reached means the request’s own time budget stopped us mid-walk, and engine_unavailable means a transient failure rather than a lack of posts. When the job form of the same endpoint is available, async_endpoint points at it — whatever the reason, because “may I retry this as a job” has the same answer either way.

Every Field a Reddit Call Returns

Named JSON fields, not HTML you have to select against. Every key is always present, so an absent value arrives as null and never as a missing key.

Post record

  • id, fullname, title, permalink, url
  • author, author_id, author_avatar
  • subreddit, subreddit_id, domain
  • score, upvote_ratio, num_comments
  • created_at, language, post_type
  • award_count, top_award.id, top_award.icon_url
  • is_nsfw, stickied, locked, archived
  • selftext, flair.text, flair.background_color
  • media.type, media.url, media.hls_url
  • thumbnail

Comment record

  • id, author, body
  • score, depth, parent_id
  • created_at, permalink, award_count
  • replies[] — only with tree=true
  • Envelope: post_id, subreddit
  • total_comments — the post’s own stated total
  • count — how many came back

Search, user and community

  • Search: id, title, author, subreddit
  • Search: subreddit_id, permalink, position
  • Search: is_nsfw, spoiler, quarantined
  • User: username, post_karma, comment_karma
  • User: cake_day, avatar
  • Community: name, subreddit_id, description
  • Community: weekly_visitors
  • Community: weekly_contributions

Request parameters

  • subreddit — posts, comments
  • name (or subreddit) — community
  • post_id — comments (t3_ prefix optional)
  • q — search, up to 512 characters
  • username — user (u/ and @ accepted)
  • sort — hot, new, top, rising
  • t — hour, day, week, month, year, all
  • limit — 1–100 sync; sets the price
  • tree — 1, true, yes or on; no extra charge

Two field names on this list are deliberately not the ones you might expect, and both are honesty decisions. A community summary returns weekly_visitors and weekly_contributions because those are the counts Reddit’s own community card states — they are not subscriber or member counts, and relabelling them as such would put a number in your dataset that Reddit never published. And total_comments on a comments call is the post’s own stated total, which is a different fact from count, the number that actually came back; it is never back-filled from count, because that would turn “we do not know” into a number.

What is Reddit data, and why teams use it

It is the record behind a post, a thread, a search, an account or a community. Four things decide whether it is usable at scale.

Reddit outranks brands on their own names

Reddit threads sit on commercial and comparison queries where a vendor’s own pages used to, which is why brand and market teams now track communities the way they track rankings. Our own guide to that pattern is Reddit outranks your brand on Google.

That job is a listing plus a search on a schedule, diffed day over day. It is the single most common reason a team needs a Reddit endpoint rather than a one-off export.

Assistants cite Reddit, so citation tracking needs it

Community threads are among the sources AI answers lean on, which makes “which thread is being cited, and what does it say” a measurable question. We wrote it up in tracking Reddit citations in AI answers.

Answering it needs the thread body, not just the link: selftext, the comment bodies, the scores and the timestamps, in a shape you can diff.

The billing unit decides whether it scales

A 100-post listing costs one call and, here, four blocks. Billed per item instead, the same listing is 100 chargeable rows — which is why the identical collection job can cost $0.48 or $150.00 per 1,000 runs depending only on who you buy it from.

So the unit is the first thing to check on any quote, ours included. Any comparison that does not state items per call is not a comparison.

A short listing has to say it is short

An incomplete pull and a quiet week look identical in a chart, and only one of them is real. The delivery block names which one: requested, returned, and a reason that separates “that is all there was” from “we ran out of time”.

That matters most when the output is a report someone else will act on. Nothing is silently truncated here to make a response look complete.

Honest about scope. These five endpoints read public Reddit. There is no write side — no posting, no commenting, no voting, no messages — and there is no full post-or-comment history for an account: /user is the profile summary, and a deep account history is not something this API sells. Reddit’s own Data API Terms govern what you may do with Reddit data whichever vendor you buy it from; read them before you build on any of this. Serpent API is not affiliated with, endorsed by or sponsored by Reddit, Inc.

Reddit API Pricing, Side by Side

Every figure is the vendor’s own published rate, read live on 2026-09-09. Units differ wildly here, so the table names each one before it names a price.

Provider What one unit is Cost per 1,000 — entry Cost per 1,000 — lowest published What the lowest rate requires Free tier
Serpent API Per call. Search, user and community are flat at any depth; a posts or comments listing is one unit per started block of 25 items. $0.12 flat call
$0.12 listing at limit=25
$0.48 listing at limit=100
$0.084 flat call
$0.084 listing at limit=25
$0.336 listing at limit=100
A single $500 deposit, spendable as balance. No monthly plan and no daily bucket; the tier never expires or downgrades. 10 free API calls
Reddit — official Data API Per API call, up to 100 items — the same unit we sell in No published retail rate No published retail rate Quote only. Commercial access is sales-gated behind a use-case review; the figure quoted around the web is a 2023 number that has been restated ever since, not a rate card you can sign up to. Free non-commercial access, rate-limited
Bright Data — Reddit Scraper API Per record — one post or one comment $1.50 (pay as you go)
= $150.00 per 100-post call
$1.30
= $130.00 per 100-post call
Scale plan, $499 per month, 384,000 records included 5,000 records/month
Apifyprodiger/reddit-scraper Per post ($0.00115) or per comment ($0.000575) at the free tier $1.15 per 1,000 posts
$0.58 per 1,000 comments
$0.28 per 1,000 posts
$0.14 per 1,000 comments
Diamond tier, enterprise/contact sales. Bronze ($19/mo) is $1.00, Silver ($199/mo) $0.78, Gold ($999/mo) $0.60, Platinum $0.40. $5 platform credit
Apifylabrat011/reddit-scraper Per result pushed to the dataset $1.50 per 1,000 results
= $150.00 per 100-post call
$1.50 (no tier ladder published) Nothing — but bandwidth is billed separately on top of every run 25 results per run
redditapis.com Per call. A listing returning 100 items costs the same as one returning three. $2.00 per 1,000 reads $2.00 (flat; no plans or tiers) Nothing. Writes, votes and DMs are separate, dearer units ($12.00, $5.00 and $25.00 per 1,000). $0.50 in credits (~250 reads)
Decodo — Web Scraping API Per successful request, with Reddit post, subreddit and user templates. Items per request are not published. $0.50 (Free and Starter, $19/mo) $0.14 Business plan, $99 per month, 707,000 standard requests. Professional ($49/mo) is $0.30. Rates rise to $1.20–$1.50 for premium or JavaScript rendering. 2,000 requests
SocialCrawl Per call, from a credit balance. Each page of a paginated pull is its own call. £6.00 (about $8.13) £1.99 (about $2.70) Pro plan, £299 per month, 150,000 credits 100 credits, one-time

How to read this table, including the row that beats us. Rates checked against each vendor’s own live pricing page on 2026-09-09; SocialCrawl publishes in GBP and is converted at the ECB reference rate for 2026-09-08 (£1 = $1.3546), so those two dollar figures move with the currency and the pound ones do not. Against the four item-billed rows we are 58× to 312× cheaper per post — $0.0048 per 1,000 posts here against $0.28 at Apify’s enterprise floor and $1.30–$1.50 at Bright Data. Read as a 100-post call those rows are $28.00 to $150.00 per 1,000 calls, against our $0.48. Against the three rows that share our per-call unit we are cheaper on every call we sell, with one exception. redditapis.com at $2.00 per 1,000 reads is 16.7× our flat rate and 4.2× our deepest listing; SocialCrawl’s Pro plan at about $2.70 is 22.5× and 5.6×; Decodo’s entry rate of $0.50 is 4.2× our flat rate. The exception is Decodo’s $0.14 floor, which is below our $0.48 at limit=100 — it needs $99 every month, it is a raw-request rate rather than a parsed-listing rate, and Decodo does not publish how many items one request returns, so the per-post comparison cannot be made at all. Our $0.12 is below that $0.14 on every flat call and every 25-post listing. Reddit’s own Data API shares our unit exactly (one call, up to 100 items, one charge), which makes it the fairest comparison of all and the one we cannot make: it has no retail rate card, and the per-1,000 figure repeated across the web traces to a 2023 announcement rather than to anything you can buy today.

What Teams Actually Pull Reddit Data For

Four jobs that account for most Reddit data traffic, and the endpoint, depth and parameters each one needs.

Brand and competitor monitoring

/api/reddit/search on a keyword list is the cheapest sweep on this API: limit does not move its price, so 100 results cost the same single charge as 10 do. Run it wide and often.

Escalate only the threads that matter into /api/reddit/comments, where depth does cost. Wide-and-flat first, deep-and-blocked second, is the pattern that keeps the bill down.

Community and trend tracking

Poll /api/reddit/posts on a subreddit list with sort=top&t=day and diff the ID set. A limit=25 daily sweep and a weekly limit=100 deep pull is usually cheaper than either alone.

Pair it with /api/reddit/subreddit for the weekly visitor and contribution counts, so a spike in posts can be read against whether the community itself grew.

Voice-of-customer and product research

/api/reddit/comments with tree=true returns nested replies[], so a disagreement stays attached to the claim it answers instead of arriving as a flat list you have to re-thread.

tree is free; only limit is charged. It accepts 1, true, yes or on, so a client that spells a boolean its own way still gets the nested shape rather than a silently flat one.

Audit-safe bulk collection

The delivery block, with requested, returned and a reason, keeps a bulk run honest: a short pull is labelled short rather than filed as a finding, and it points at the job form of the same endpoint.

For anything deeper than 100 items, submit it as a job: up to 250 posts or 1,000 comments, on the same block ladder and with no premium of its own.

Bash — daily subreddit sweep, on the block boundary
# One line per community: date, name, posts returned, top score.
# limit=25 is one block and the cheapest call — deepen only when it pays.
while IFS= read -r sub; do
  curl -s -G "https://apiserpent.com/api/reddit/posts" \
      --data-urlencode "subreddit=$sub" -d "sort=top" -d "t=day" -d "limit=25" \
      -H "X-API-Key: $SERPENT_API_KEY" \
    | jq -r --arg s "$sub" \
        '[$s, (.count|tostring), ([.posts[].score] | max | tostring),
          (.delivery.reason // "complete")] | @csv' \
    | sed "s|^|$(date -u +%F),|" >> reddit-daily.csv
done < subreddits.txt

Reddit API Questions

Yes. /api/reddit/posts, /comments, /search, /user and /subreddit are live and answering on any Serpent API key. Everything on this page is read out of the code that serves them rather than drafted for marketing: the parameters, the caps, the fields and the rates. A signed-up account gets 10 free API calls with no card and no commitment, and Reddit is one of the endpoints they can be spent on.
One rate for all five endpoints: $0.12 per 1,000 calls on Default, $0.108 on Growth, $0.084 on Scale. search, user and subreddit are that flat charge at any depth. A posts or comments listing is charged one unit per started block of 25 items, so limit=25 is $0.12 per 1,000 calls and limit=100 is $0.48 per 1,000 calls. Growth unlocks at a single $100 deposit and Scale at $500; both are one-time and neither ever downgrades.
A call, not an item. A search call returns up to 100 results for one charge of $0.12 per 1,000 calls — $0.0012 per 1,000 results. A 100-post listing is charged as four blocks, $0.48 per 1,000 calls, which is $0.0048 per 1,000 posts. Most well-known Reddit data vendors bill per post or per record instead: read as a 100-post call, that is $28.00 to $150.00 per 1,000 calls on their own published rates, against our $0.48. That gap is the whole commercial argument here, and it only holds if the items-per-call figure is stated — which is why it is stated in every row of the comparison table.
Because a block is charged whole. A posts or comments call is priced per started block of 25 items, so 26 items opens a second block and pays for it in full. Ask for 25, 50, 75 or 100 and the per-post price is a flat $0.0048 per 1,000 posts on Default; ask for 26 and you pay $0.0092 per 1,000 posts for the same data. Set limit on a 25 boundary. It is the one parameter on this API that changes your invoice.
Five. /posts is a subreddit listing sorted hot, new, top or rising. /comments is one post’s comments, flat or nested with tree=true (1, yes and on work too). /search is post search across Reddit. /user is a profile summary — post karma, comment karma, cake day and avatar. /subreddit is a community summary — name, description and the weekly visitor and contribution counts, emitted under their own names rather than relabelled as member counts. There is no write side: no posting, no commenting, no voting and no messages.
You get what we hold, and the response says so. A short listing carries a top-level delivery block with requested and returned, a machine-readable reason and a sentence, plus a pointer to the job form of the same endpoint when that form is available. The reason separates the two situations that look identical in a chart: fewer_available means we walked to the end and that is all there was, deadline_reached means the request’s time budget stopped us. Nothing is silently truncated to make a response look complete.
Yes, and that is deliberate. Going and looking is the product: a settled “that community is not there” is a true, complete, useful answer, so it answers 404 and is charged. Anything that is our own failure — a request that could not be completed, or one that ran out of time — answers 503 or 504 and the credit is refunded automatically. The two cases never wear each other’s status code, so you are never charged for our failure and never given a dead identifier free of charge.
Yes, on all five operations. The job form holds no client socket, so it has a bigger time budget and accepts deeper listings: up to 250 posts and up to 1,000 comments, against the 100-item cap on the synchronous route. It is priced on exactly the same 25-block ladder — a 25-item job is never billed at the 1,000-item rate — and there is no bulk premium or multiplier beyond that ladder. A very long comment thread can be capped to fit the stored result, and when that happens the response says so rather than quietly returning less.
On one call at one vendor, yes, and the comparison table on this page shows it rather than hiding it. Decodo’s cheapest published rate is $0.14 per 1,000 requests on a $99-a-month plan, which is below our $0.48 for a 100-post listing — though it is a raw-request rate, and Decodo does not publish how many items one request returns, so it cannot be compared per post at all. Everywhere else we are the cheapest published rate we could find. Our $0.12 per 1,000 calls is below Decodo’s $0.14 floor and its $0.50 entry rate, below redditapis.com’s $2.00 per 1,000 reads, and below SocialCrawl’s $2.70 Pro rate. Against the vendors that bill per item rather than per call — Bright Data at $1.50 per 1,000 records, Apify at $1.15 falling to $0.28 per 1,000 posts — we are 58 to 312 times cheaper per post at $0.0048 per 1,000. All of it re-read on each vendor’s own pricing page on 2026-09-09.
Neither. There is no monthly plan anywhere in Serpent’s pricing and no per-day allowance. Growth and Scale are earned by a single deposit of $100 and $500, that deposit is spendable balance rather than a fee, and the tier is permanent — it never downgrades if your usage drops. A signed-up account also gets 10 free API calls, shared across every free-eligible endpoint, with no card required — and a free call consumes exactly one free unit however deep the listing is.

Start using the Reddit API

10 free API calls, shared across every free-eligible endpoint. No card, no subscription, no monthly plan and no daily bucket. Reddit posts, comments, search, users and communities from $0.084/1K calls.

Get your free API key

Related guides

More on working with community and social data in code.

Reddit Outranks Your BrandTracking community threads on your own commercial queries. Reddit Citations in AI AnswersWhich threads get cited, and how to watch them move. Social Media APIEvery social surface in the catalog, on one key. TikTok APIProfile, video, hashtag, search and music, in one envelope. Instagram APIProfiles and recent posts in the same call, at the same price. YouTube APIChannel, video and search data without a quota unit. The Cheapest SERP API in 2026A full cost comparison across every major provider. PricingEvery published rate, and the two one-time deposit tiers.