Reddit API with Bun: A Native fetch Client in TypeScript (2026)

The Reddit API works in Bun with nothing to install. Bun ships a native fetch, runs TypeScript directly, and starts in milliseconds, so the Reddit API is one HTTPS request with an Authorization: Bearer header and a typed interface you write yourself. There is no wrapper, no OAuth developer app, no tsc build step, and no client ID. A single bearer token from redditapis.com reads posts, search, comment trees, and users from a client you can run with bun run.

Not affiliated with Reddit Inc. redditapis.com is an independent third-party REST proxy for Reddit's API.

---

TL;DR: Bun's native fetch plus one bearer token is a complete Reddit client, and Bun runs the TypeScript directly with no build. Skip snoowrap and the OAuth app flow. Read posts, search, and walk comment trees with a typed get<T> helper, proxy the browser safely through Bun.serve, and cache reads with bun:sqlite. Reads cost $0.002 per call (pricing).

What you will build:

• A working GET /api/reddit/posts call in Bun in five lines, no wrapper
• A typed client Bun runs directly, no tsc and no bundler
• Reads for posts, search, comments, and users
• A safe browser proxy with Bun.serve that hides the key
• A read-through cache on Bun's built-in SQLite

Cost: $0.002 per read call. Free credit at signup. No card required.

---

Why Bun Developers Drop the Wrapper

Most JavaScript Reddit tutorials open with npm install snoowrap, register a Reddit developer app, and bolt on an OAuth flow. That advice creaks in 2026, and it creaks harder in Bun. The top wrapper, snoowrap, has not shipped a meaningful release in years, and developers say so out loud when they go looking:

Rohit Dasu

@rohitdasudotcom

Hi twitter 𝕏 developer community, is there any good wrapper package for reddit API for js/nodejs? I got to know about snoowrap. But it was last published 3 years ago. Let me know any updated packages that is good. Thanks :)

Bun removes the two reasons a wrapper felt necessary in the first place. Bun's native fetch, documented at bun.sh, means there is no axios or node-fetch to install, and Bun's first-class TypeScript, described at bun.sh/docs, means the wrapper's typed-helper selling point is redundant. A wrapper that assumes Reddit's older anonymous or free-OAuth world also assumes an access model that changed: Reddit moved commercial use behind a paid tier in its Data API terms, and the developer-app path on reddit.com/dev/api stayed slow through 2025 and 2026.

The modern answer is to drop the wrapper and point Bun's fetch at a managed REST endpoint that handles the Reddit session internally. You get reads with one bearer token, full TypeScript types you own, and nothing to keep patched. This tutorial does what the snoowrap guides did, reads posts, searches, walks comment trees, and fetches users, with native fetch and $0.002 per read call (pricing). For the Node.js contrast, see the Node.js and TypeScript tutorial, and for a language-agnostic map, the Reddit data API overview.

---

Setup: One Key, Zero OAuth

The credential story is one bearer token. Generate it at signup, put it in a .env file, and Bun loads it automatically, no dotenv package required:

echo 'REDDITAPI_KEY=YOUR_API_KEY' > .env
bun --version   # confirm Bun 1.1 or newer

Bun reads .env into Bun.env and process.env at startup, so Bun.env.REDDITAPI_KEY is available without any loader. Keep the key server-side. Never commit it, and never ship it to the browser, because a bearer token in client-side JavaScript is readable by anyone who opens dev tools. If a frontend needs Reddit data, proxy it through a Bun.serve route, which the section below shows. The base URL is https://api.redditapis.com, and the key goes in the Authorization: Bearer header on every request. For how keys and auth work, see how to get a Reddit API key and the authentication overview.

---

Quick Start: The Reddit API in Bun in Five Lines

First prove the endpoint from the shell so you see the raw JSON:

curl -s -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.redditapis.com/api/reddit/posts?subreddit=bun&sort=top&t=week&limit=5"

That returns a { "posts": [...], "after": "..." } object. Now the same call in a Bun TypeScript file, run directly with bun run reddit.ts:

const BASE = "https://api.redditapis.com";
const KEY = Bun.env.REDDITAPI_KEY!;

const res = await fetch(`${BASE}/api/reddit/posts?subreddit=bun&sort=top&limit=5`, {
  headers: { Authorization: `Bearer ${KEY}` },
});
const { posts } = await res.json();
console.log(posts.map((p: { title: string }) => p.title));

Five lines of real work, and Bun runs the TypeScript with no compile step. Note two habits that save debugging time. First, the fields are upvotes and comments, not ups or num_comments, so match your interface to the live response. Second, the response is wrapped: reads return { posts: [...] }, not a bare array, so you destructure posts. Top-level await works because Bun files are modules. The sort accepts top, new, hot, and rising, and t bounds the window for top. The full parameter list is in the Reddit data API overview.

---

A Typed Client: Bun Runs TypeScript Directly

The reason a wrapper felt necessary in JavaScript was types and ergonomics. Bun gives you both with zero setup, because it runs .ts directly and the response shape is stable JSON you can describe with an interface:

const BASE = "https://api.redditapis.com";
const KEY = Bun.env.REDDITAPI_KEY!;

export interface RedditPost {
  id: string;
  name: string;          // fullname, e.g. "t3_abc123"
  title: string;
  author: string;
  subreddit: string;
  permalink: string;
  upvotes: number;
  comments: number;
  upvote_ratio: number;
  created_utc: number;
}

async function get<T>(path: string, params: Record<string, string> = {}): Promise<T> {
  const qs = new URLSearchParams(params).toString();
  const res = await fetch(`${BASE}${path}${qs ? `?${qs}` : ""}`, {
    headers: { Authorization: `Bearer ${KEY}` },
  });
  if (!res.ok) throw new Error(`Reddit API ${res.status}: ${await res.text()}`);
  return res.json() as Promise<T>;
}

const { posts } = await get<{ posts: RedditPost[] }>("/api/reddit/posts", {
  subreddit: "typescript", sort: "top", limit: "10",
});

That is the whole client. get<T> gives autocomplete, compile-time field safety, and one place to handle non-2xx responses, with no code generation and no build. Developers keep reaching for a library because the named wrappers stalled; in Bun the honest answer is a typed fetch helper you own, and one developer's habit of leaning on whatever library is easiest is exactly the pull this replaces:

Amaan

@dextertwts

basically a wrapper for reddit API calls. Instead of going through docs I use this easy library https://t.co/cm3bb8E5oG

Because every endpoint returns the same JSON shape, the same get<T> covers search, comments, and users. For deeper runtime validation with Zod, see the TypeScript typed-client deep dive.

---

Reading Reddit Data: Posts, Search, Comments, Users

The read surface is a handful of GET endpoints, all $0.002 per call (pricing), all through the same get<T> helper. This is the core of most Bun Reddit projects: monitors, pipelines, and research tools.

Keyword search across Reddit is /api/reddit/search with a q parameter, returning an after cursor alongside the posts. User profiles come from /api/reddit/user/{name}. Verify search from the shell, then call both in Bun:

curl -s -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.redditapis.com/api/reddit/search?q=bun+runtime&sort=top&t=year&limit=5"

const search = await get<{ posts: RedditPost[]; after: string | null }>(
  "/api/reddit/search", { q: "bun vs node", sort: "top", t: "year", limit: "25" },
);

interface RedditUser {
  name: string;
  link_karma: number;
  comment_karma: number;
  total_karma: number;
  created_utc: number;
}
const user = await get<RedditUser>("/api/reddit/user/spez");
console.log(`${user.name}: ${user.total_karma} total karma`);

Comment trees come from /api/reddit/comments with a permalink parameter, the path already on every post. Pass a post's permalink and you get the post plus its threaded comments in one response. The r/node community trades exactly these "how should I structure my API layer" questions that a typed client answers:

r/

r/node·u/Lanky-Ad4698

Any courses that are practical DDD/Clean Architecture in TS? Queue, Event Bus, Mailer, Payment Gateway, AuthProvided Interfaces?

00

Open on Reddit

For keyword-driven work, the Reddit search API tutorial goes deeper, and how to find subreddits by API covers community discovery.

---

Pagination with the after Cursor

Listing endpoints cap a single response, so walking a whole subreddit means following the after cursor. Pass the previous page's after back as the after parameter, and stop when it comes back empty:

async function fetchAll(subreddit: string, max = 300): Promise<RedditPost[]> {
  const all: RedditPost[] = [];
  let after: string | null = null;
  while (all.length < max) {
    const page = await get<{ posts: RedditPost[]; after: string | null }>(
      "/api/reddit/posts",
      { subreddit, sort: "new", limit: "100", ...(after ? { after } : {}) },
    );
    all.push(...page.posts);
    if (!page.after || page.posts.length === 0) break;
    after = page.after;
  }
  return all.slice(0, max);
}

The cursor is opaque, so you only echo back the previous page's value. This is the same pattern the curl and Go clients use, so a pipeline you prototype in the shell ports to Bun unchanged. The video below walks the Bun runtime fundamentals that make a script like this start instantly:

For streaming-style monitoring instead of batch pagination, weigh the tradeoffs in webhooks versus polling for Reddit data streams.

---

A Safe Browser Proxy with Bun.serve

A bearer token must never reach the browser. Bun's built-in HTTP server, Bun.serve (documented at bun.sh/docs/api/http), puts a thin proxy in front of the API in a few lines: the server holds the key, the browser calls your route, and your route calls the API:

const BASE = "https://api.redditapis.com";
const KEY = Bun.env.REDDITAPI_KEY!;

Bun.serve({
  port: 3000,
  async fetch(req) {
    const url = new URL(req.url);
    if (url.pathname !== "/api/posts") return new Response("Not found", { status: 404 });

    const subreddit = url.searchParams.get("subreddit") ?? "bun";
    const upstream = await fetch(
      `${BASE}/api/reddit/posts?subreddit=${encodeURIComponent(subreddit)}&limit=25`,
      { headers: { Authorization: `Bearer ${KEY}` } },
    );
    return new Response(await upstream.text(), {
      headers: { "Content-Type": "application/json" },
      status: upstream.status,
    });
  },
});

The browser now talks to localhost:3000/api/posts?subreddit=bun and never sees the key. This is the one rule that keeps a public Bun app safe: read the token server-side, expose only the routes you choose, and validate the subreddit parameter so a caller cannot pivot the proxy to an arbitrary endpoint. For a frontend that renders Reddit data, this route is the entire backend. See how to send a Reddit DM via API for the write-side pattern behind an authenticated route.

---

Caching Reads with Bun's Built-in SQLite

Bun ships a fast SQLite driver, bun:sqlite, documented at bun.sh/docs/api/sqlite, so a read-through cache is a table and two queries with no external dependency. Caching each subreddit read for a short window cuts repeat calls and cost:

import { Database } from "bun:sqlite";
const db = new Database("cache.sqlite");
db.run("CREATE TABLE IF NOT EXISTS cache (k TEXT PRIMARY KEY, body TEXT, ts INTEGER)");

async function cachedPosts(subreddit: string, ttlSec = 300): Promise<RedditPost[]> {
  const key = `posts:${subreddit}`;
  const row = db.query("SELECT body, ts FROM cache WHERE k = ?").get(key) as
    | { body: string; ts: number } | null;
  if (row && Date.now() / 1000 - row.ts < ttlSec) {
    return JSON.parse(row.body);
  }
  const { posts } = await get<{ posts: RedditPost[] }>("/api/reddit/posts", { subreddit, limit: "50" });
  db.run("INSERT OR REPLACE INTO cache (k, body, ts) VALUES (?, ?, ?)",
    [key, JSON.stringify(posts), Math.floor(Date.now() / 1000)]);
  return posts;
}

A 300-second cache on a monitor that polls one subreddit every few seconds collapses hundreds of reads into a handful. At $0.002 per read (pricing), the savings on a busy monitor are real, and Bun's SQLite is fast enough that the cache lookup adds no meaningful latency. Reddit's own commercial tier starts at a $12,000 per year minimum (Reddit's Data API terms), so keeping per-call cost low with a cache is exactly how a small Bun app stays affordable.

---

Concurrent Fetching with Promise.all

Fetching ten subreddits one after another wastes time in serial round trips. Because each read is an independent fetch, Promise.all runs them concurrently and collapses ten round trips into roughly one:

async function fetchMany(subs: string[]): Promise<Record<string, RedditPost[]>> {
  const results = await Promise.all(
    subs.map((s) =>
      get<{ posts: RedditPost[] }>("/api/reddit/posts", { subreddit: s, limit: "25" })
        .then((r) => [s, r.posts] as const)
        .catch(() => [s, [] as RedditPost[]] as const), // isolate one failure
    ),
  );
  return Object.fromEntries(results);
}

const feeds = await fetchMany(["bun", "node", "typescript", "webdev"]);

The per-subreddit .catch isolates a single failure so one bad response does not sink the batch. For very large fan-outs, cap concurrency so you stay a good client rather than firing a thousand requests at once. Because reads are $0.002 each (pricing), a wide survey stays cheap, and Bun's fast startup means a scheduled fan-out script spins up and exits in a blink. The r/webdev community regularly debates client-side versus server-side data patterns that these proxy-and-fan-out habits settle:

r/

r/webdev·u/Ambitious-Garbage-73

I audited 6 months of PRs after my team went all-in on AI code generation. The code got worse in ways none of us predicted.

00

Open on Reddit

---

Production Patterns: Retries and Error Handling

Any HTTP call can return a transient 429 or 5xx, so wrap requests in exponential backoff. GET reads are safe to retry because they are idempotent:

async function withRetry<T>(fn: () => Promise<T>, max = 3): Promise<T> {
  for (let attempt = 0; ; attempt++) {
    try {
      return await fn();
    } catch (err) {
      const status = Number(String(err).match(/Reddit API (\d+)/)?.[1] ?? 0);
      const transient = status >= 500 || status === 429;
      if (!transient || attempt >= max - 1) throw err;
      await Bun.sleep(2 ** attempt * 500); // 0.5s, 1s, 2s
    }
  }
}

Bun.sleep is the built-in delay, so you do not import a timer helper. The status taxonomy is short and each code names its own fix: 401 is always a missing or wrong header, 402 is out of credit (pricing), 404 is a wrong path or deleted resource, and 429 or 5xx are transient and belong to the retry wrapper. Reading the response body on a failed request gives you the JSON error, which almost always names the exact problem. For the numbers behind a healthy request budget, see Reddit API rate limits 2026.

---

Bun for Reddit in the 2026 AI-Agent Era

Bun's fast startup and native fetch make it a strong fit for the fastest-growing Reddit use case in 2026: a tool inside an AI agent. An agent that reads Reddit is a get<T> call behind a tool schema, and Bun's cold-start speed matters when a serverless function spins up per invocation. The value of a bearer-token REST endpoint here is that the tool never manages an OAuth lifecycle. Reddit is one of the most-cited sources in AI answer engines, which is why live Reddit reads are a common agent capability. For the agent-facing packaging, see the Reddit API for AI agents guide and how to build a Reddit MCP server.

The caching and proxy patterns above carry straight into an agent deployment. A Bun.serve route that fronts the API and a bun:sqlite cache in front of that give an agent fast, cheap, repeatable reads without exposing the key or re-fetching the same subreddit on every turn.

---

What the Reddit API Costs for a Bun App

Cost depends on which endpoints you call, not on a per-seat subscription. Reads are $0.002 each, votes $0.005, comments and logins $0.012, and direct messages $0.025 (full per-call pricing). Three concrete Bun scenarios:

Bun scenario	Monthly calls	Approx cost
Cached subreddit monitor	~10,000 reads after cache	about $20 (pricing)
Agent tool (50,000 reads/month)	50,000 reads	about $100 (pricing)
Weekend project (a few hundred reads)	~300 reads	covered by free credit (pricing)

Most Bun Reddit apps are read-heavy and bursty, which is the shape usage pricing fits: you pay $0.002 per read for exactly the calls you make (pricing), and the SQLite cache cuts even that. Model your exact numbers with the cost calculator and compare access paths on the pricing page.

---

A Complete Reddit Monitor Endpoint in Bun

The pieces above assemble into the shape most Bun Reddit projects actually ship: a single-file service that exposes a monitored subreddit as an HTTP route, caches reads, and refreshes on a timer. Bun's fast startup and built-in server make this a small program you can deploy as one file:

import { Database } from "bun:sqlite";
const db = new Database("cache.sqlite");
db.run("CREATE TABLE IF NOT EXISTS cache (k TEXT PRIMARY KEY, body TEXT, ts INTEGER)");

// Refresh the cache on a schedule so the route is always fast.
setInterval(() => cachedPosts("bun", 0), 60_000); // force refresh every 60s

Bun.serve({
  port: 3000,
  async fetch(req) {
    const url = new URL(req.url);
    if (url.pathname !== "/feed") return new Response("Not found", { status: 404 });
    const sub = url.searchParams.get("subreddit") ?? "bun";
    const posts = await cachedPosts(sub, 300);
    return Response.json({ subreddit: sub, count: posts.length, posts });
  },
});

The setInterval refresher and the cached route separate freshness from request latency: the timer pays the API cost on a schedule, and every browser request reads from SQLite instantly. Response.json is Bun's shorthand for a JSON response, so the route stays terse. This is the whole backend for a dashboard that shows a live subreddit feed, and it is one file you deploy without a build step. Because the timer controls how often you pay for a read, the cost is predictable regardless of how much traffic the route gets: 1,440 refreshes a day is under $3 a month for one subreddit (pricing), no matter whether one user or a thousand hit the feed. For the streaming alternative to timer-based refresh, see webhooks versus polling.

Bun's startup speed changes the deployment math too. Because a Bun process is ready in milliseconds, this service works well in a serverless or per-request-container model where a slow cold start would otherwise hurt, and the SQLite cache can live on a mounted volume so it survives restarts. The r/node community regularly compares runtime tradeoffs that push developers toward Bun for exactly this kind of small, fast service:

r/

r/node·u/Intelligent_Camp_762

Your internal engineering knowledge base that writes and updates itself from your GitHub repos

00

Open on Reddit

Testing a Bun Reddit Client with the Built-in Runner

Bun ships a test runner, so you can test your client without installing Jest or Vitest and without spending an API call. The runner reads .test.ts files and gives you expect out of the box, and bun test runs them in a blink. The pattern is to point the client at a stub server and assert it sends the header and decodes the response:

import { test, expect } from "bun:test";

test("posts decode with the right fields", async () => {
  const stub = Bun.serve({
    port: 0, // random free port
    fetch(req) {
      expect(req.headers.get("Authorization")).toBe("Bearer test-key");
      return Response.json({ posts: [{ id: "a", title: "hi", upvotes: 9, comments: 2 }], after: "" });
    },
  });
  // point the client base at `http://localhost:${stub.port}` and assert upvotes === 9
  stub.stop();
});

Testing against a stub means you assert the bearer header is set, the JSON decodes into the right shape, and error branches behave, all offline and instantly. This discipline matters more with a paid API than a free one, because a test suite that called the live endpoint would cost money and be flaky. The bun:test runner's speed makes running the suite on every save painless, so you catch a broken decode the moment you introduce it rather than in a manual check later. Pair the tests with structured logging of every request's status and elapsed time, and you have the two things a long-running Bun service needs that a prototype skips.

Deploying and Securing a Public Bun Reddit App

Once a Bun Reddit service faces the public internet, three habits keep it safe and cheap. First, the key stays server-side, which the Bun.serve proxy already guarantees, but you should also validate every parameter a caller can influence, so the subreddit value cannot be used to pivot your proxy to an arbitrary endpoint. An allowlist of permitted subreddits, or a strict pattern check, turns an open proxy into a controlled one. Second, add a small per-caller rate limit on your own route so one abusive client cannot run up your API bill, since every proxied read is a real $0.002 charge (pricing). A token bucket keyed on the caller's IP, backed by the same SQLite you already have, is a few lines. Third, set a request timeout on your upstream fetch so a slow API response never holds a connection open indefinitely, using AbortSignal.timeout which Bun supports natively.

The economic point is that a public proxy inverts who pays for reads: without a rate limit, your callers spend your credit. With one, you cap your exposure and keep the service affordable even under load. This is the same reasoning behind the timer-based cache above, and together the two patterns, a scheduled refresh plus a per-caller limit, make a public Bun Reddit app both fast and cost-bounded. Reddit's own commercial tier starts at a $12,000 per year minimum (Reddit's Data API terms), so the whole reason a small Bun app is viable is keeping per-call cost low and controlled. The r/webdev community debates these self-hosting and cost-control tradeoffs constantly:

r/

r/webdev·u/nhrtrix

Is IndexedDB actually... viable in 2026? Or am I wasting my time?

00

Open on Reddit

Bun Versus Node for a Reddit Client

If you already know how to call the Reddit API from Node, the question is what Bun actually changes, and the honest answer is that the API code is nearly identical while the surrounding developer experience is meaningfully lighter. Both runtimes have a global fetch, so the request itself is the same line in either, whether you run it on Node or Bun. What differs is everything around that line. Bun runs TypeScript directly, so there is no tsc step, no ts-node, and no build configuration to maintain, which means a Reddit script is a single .ts file you run with one command. Bun loads .env automatically, so there is no dotenv import. Bun ships a test runner and a SQLite driver, so the two things a Node Reddit service usually pulls in as dependencies are built in. The result is fewer moving parts for the same client.

The performance difference shows up most at the edges of a service's life: startup and small hot loops. Bun starts faster than Node, which matters when a Reddit tool runs as a short-lived process, a serverless function, or a per-request container, because a slow cold start there is user-visible latency. For a long-running monitor the startup difference is a one-time cost that does not matter, but for a function that spins up per invocation it is exactly the cost you feel. This is why a Bun Reddit client pairs so well with the scheduled-refresh and cached-route patterns above: the runtime's strengths, fast startup and built-in storage, line up with the shape of a small, cheap, frequently-invoked Reddit service.

None of this makes Node wrong. Node has the larger ecosystem, longer production track record, and broader hosting support, so a team standing on Node infrastructure has every reason to stay there, and the Node.js and TypeScript tutorial covers the identical client on that runtime. The point is not that Bun replaces Node for Reddit work, but that if you are starting fresh or want the lightest possible setup, Bun removes several steps without changing the API code you write. The bearer token, the endpoints, the response shapes, and the pagination are all the same, so a client you write for one runtime ports to the other with almost no change, and moving between them is a runtime swap rather than a rewrite. That portability is itself a reason to keep the client small and standard rather than leaning on runtime-specific tricks in the request layer, reserving Bun's built-ins for the storage and serving layers where they add the most.

The migration story runs both ways, too. A Reddit client prototyped in Bun for its fast iteration can move to Node for production if that is where a team's deployment tooling lives, and a Node client can move to Bun to shed its build step and dependency count. Because the API surface is a REST endpoint with one header, neither move touches the part of the code that talks to Reddit. That is the quiet advantage of building on a plain HTTP surface instead of a runtime-specific wrapper: the client is portable by default, and the runtime becomes an implementation detail you can revisit as your deployment needs change rather than a decision locked in at the first line of code.

Ship It

The Reddit API in Bun is not a wrapper problem, it is a fetch problem Bun already solves natively. Bun's built-in fetch, one bearer token, a typed get<T> helper, a Bun.serve proxy, and a bun:sqlite cache replace the entire snoowrap-plus-OAuth stack, and Bun runs all of it as TypeScript with no build. Skip the unmaintained wrappers and the approval queue, describe your response shapes with an interface, and you have a production Reddit client that starts in milliseconds.

The whole client fits in a single .ts file you run with bun run: a base URL, a key from Bun.env, a generic get<T> for reads, a fetchAll for pagination, a Bun.serve route for the browser, and a SQLite cache for cost. Generate a key and make your first call in about two minutes: sign up for free, no card required, and the whole thing runs with a single bun run and no build. When you are ready to wire Reddit into an agent, the Reddit MCP server guide picks up where this leaves off, and the Node.js and TypeScript tutorial covers the same client on Node.