Reddit Media API: Fetch Images, Videos and Galleries Programmatically (2026)

If you have ever tried to pull images out of a subreddit, or download a video someone posted, and found the API hands you a web page instead of a file, you are not doing it wrong. Reddit stores media across three hosts in three different shapes, and none of them is a single ready-to-download field. A photo lives on i.redd.it, a Reddit-hosted video lives on v.redd.it as split audio and video tracks, and a multi-image gallery returns a gallery_data map you have to resolve yourself. This guide explains exactly what each media type looks like, how to fetch images, videos, and galleries over a plain REST call, and how to pull Reddit media at scale in 2026.

Not affiliated with Reddit Inc. redditapis.com is an independent, third-party REST layer built on Reddit's official API.

Last updated 2026-08-02.

TL;DR: Reddit media comes in three shapes and each needs different handling. Single images sit on i.redd.it as the post url. Reddit-hosted videos sit on v.redd.it and split audio from video behind a DASH manifest, so a naive download is silent until you mux the tracks. Galleries return a gallery_data list of media_id values plus a media_metadata map you resolve into image links. A managed media endpoint flattens all three: GET /api/reddit/search/media?q=...&kind=image|video|gallery|all returns each post with a media_url, a kind, and is_video/is_gallery flags. Use /signup to test it, or read the pricing guide.

• Images live on i.redd.it; the post url is the full-resolution file
• Videos live on v.redd.it as split DASH tracks; you mux audio and video to get sound
• Galleries return gallery_data plus media_metadata, not direct image URLs
• One media endpoint returns media_url + kind and handles all three cases

Does the Reddit API let you download images, videos, and galleries?

Yes, the Reddit API exposes media on every post, but it does not give you one clean download field that works for all three types. Instead it returns a media type per post and points you at the right host: a single image post carries its file on i.redd.it, a Reddit-hosted video post points at v.redd.it, and a gallery post points at a reddit.com/gallery/<id> page while the real images sit in a separate metadata block. The work is in knowing which shape you have and handling each one. Developers hit this constantly, usually while trying to pull every image from a subreddit, in threads like this one asking whether the Reddit API even allows downloading images rather than scraping.

The three media shapes split cleanly by what the post object hands back, and a media search returns a normalized version of each so you branch on one field instead of three.

The practical takeaway is that "download Reddit media" is really three jobs wearing one name. Getting an image is a direct download; getting a video means dealing with split streams; getting a gallery means resolving a metadata map into a list. A media endpoint does the classification for you and returns a media_url plus a kind, so the rest of this guide walks each type and shows the one call that covers all of them. A short visual overview of pulling images from Reddit with Python sets the scene:

The one call: /search/media for images, videos and galleries

To fetch Reddit media over REST, you send one authenticated request to a media search endpoint and read back a normalized list of media posts. There is no OAuth app to register, no HTML to parse, and no per-type branching before you even have the data: the endpoint runs a Reddit search, keeps only the posts that carry media, classifies each one, and returns a clean object. The call takes a query plus an optional kind filter and an optional sort and time window, and it is built on Reddit's own documented search endpoint so the query syntax is the same one you already know. Here it is in curl, using your API key in place of the placeholder:

curl -s "https://api.redditapis.com/api/reddit/search/media?q=subreddit%3AEarthPorn&kind=image&limit=3&sort=top&t=week" \
  -H "Authorization: Bearer YOUR_API_KEY"

Run against the live API on 2026-08-02, that call returned three image posts from r/EarthPorn, each with a media_url on i.redd.it, a thumbnail on preview.redd.it, and the flags below. The same request in Python, printing each post's media link:

import requests

API_KEY = "YOUR_API_KEY"

resp = requests.get(
    "https://api.redditapis.com/api/reddit/search/media",
    headers={"Authorization": f"Bearer {API_KEY}"},
    params={"q": "subreddit:EarthPorn", "kind": "image", "limit": 3, "sort": "top", "t": "week"},
    timeout=30,
)
resp.raise_for_status()
data = resp.json()

for p in data["posts"]:
    print(f"[{p['kind']:>7}] r/{p['subreddit']}  {p['media_url']}")

The response is a posts array plus an after cursor and a filtered_from count that tells you how many raw results were narrowed to media. A first-party call on 2026-08-02 returned the top r/EarthPorn image as https://i.redd.it/g3yalyfgn5gh1.jpeg, titled "Screaming Face, Madeira / Portugal", with a preview.redd.it thumbnail and is_video/is_gallery both false. The one endpoint replaces the three-way branch you would otherwise write against Reddit's raw post objects, and it pairs with the Reddit search API tutorial for the text-search side.

The media response, field by field

A media API is only as useful as the fields it hands back, and the media endpoint returns a flat, predictable object per post rather than the sprawling raw Reddit shape. Every media post comes back with the identifiers you need to attribute it, the media host URL you download from, a small preview for grids, and the two boolean flags that tell you which handling branch to take. Knowing the shape upfront means you never probe the response by trial and error.

The media search response returns these fields per post.

Two fields do most of the work. media_url is the hosted asset: an i.redd.it file for an image, a v.redd.it base for a video, or a reddit.com/gallery/<id> page for a gallery. kind is the classification (image, video, or gallery) that tells you how to treat media_url, and it is backed by is_video and is_gallery booleans if you prefer to branch on those. Alongside the posts array, the response carries an after cursor for pagination and a filtered_from count so you always know how aggressively the media filter trimmed the raw search. Because everything arrives as clean JSON, you drop it straight into a pipeline without an HTML-stripping step, unlike the RSS feed path which returns presentation markup.

Images: from i.redd.it to the full-resolution file

An image post is the simplest media type, because Reddit hands you the full-resolution file directly. For a single-image submission, post_hint is "image" and the post's url is the https://i.redd.it/<id>.jpeg (or .png) source, which is the actual upload at full size. Reddit also generates a set of resized copies under preview.images[0].resolutions, from small thumbnails up to a capped source, which are handy when you want a grid without downloading every original. A media endpoint returns the full-size i.redd.it link as media_url and the small crop as thumbnail, so you never confuse the two.

Here is what an image post actually returns, using the live r/EarthPorn result.

The one thing worth knowing is the difference between the source and the preview. The i.redd.it URL in media_url is the original file, so that is what you download when you want the real image. The preview.redd.it URL in thumbnail is a resized, cropped, and re-encoded copy Reddit made for feeds, and it carries query parameters and a signature, so it is not a clean original. For a dataset you want the source; for a fast visual index you want the preview.

On Reddit's own raw JSON, documented in the Reddit Data API reference, the resized variants live under preview.images[].resolutions, each an object with a url, a width, and a height, ordered from smallest to largest, so you can pick the size that fits your layout without downloading the full-resolution original. There is one edge to watch: the preview block is only enabled when Reddit has generated previews, and cross-posted or externally hosted images can carry an external-preview.redd.it URL instead of an i.redd.it source, which is a preview rather than a real upload. A media endpoint smooths this by always putting the best download URL in media_url, but if you parse the raw JSON yourself, prefer the post url for an i.redd.it image and fall back to preview only when the source is not a direct upload. The scraping guide covers why pulling these over the API beats parsing them out of HTML that changes shape without warning.

Videos: the v.redd.it split-stream problem

Video is where most Reddit media downloaders trip, because a Reddit-hosted video is not a single MP4 file. Reddit stores the picture track and the audio track separately and serves them through a DASH manifest, so if you grab the obvious URL you get a clip with no sound. In the raw post the details sit under media.reddit_video: a fallback_url pointing at the highest-quality video track (no audio), a dash_url ending in DASHPlaylist.mpd, and an hls_url ending in HLSPlaylist.m3u8. To get a playable file with audio you either let a DASH-aware player read the manifest, or you download both tracks and mux them with a tool like FFmpeg. A media endpoint returns the v.redd.it base as media_url and sets is_video: true, so you know to run that step.

The split is the single most-reported Reddit media surprise, and it has spawned a small industry of tools that exist only to glue the two tracks back together.

r/

r/redditdev·u/vonpapen

I built a website that allows you to download v.redd.it videos

00

Open on Reddit

Once you know the tracks are separate, the fix is mechanical, but it is a real pipeline rather than a single download.

The recurring question in the developer community is exactly this: how do you turn a v.redd.it link into a real file, and why is the sound missing when you do it the naive way.

r/

r/redditdev·u/mtb12399

How to download video from reddit

00

Open on Reddit

The reason the split exists is that Reddit serves video with MPEG-DASH, the same adaptive-streaming approach big video platforms use: the picture is offered at several bitrates and the audio is a separate track, and a player picks the right video rendition for the viewer's connection at play time. That is great for streaming and awkward for downloading, because "the file" is really a manifest that references several files. If you build the pipeline yourself with a wrapper like PRAW, you read submission.media["reddit_video"]["fallback_url"] for the top video track, then fetch the audio track referenced by the dash_url manifest, then mux the two. The DASH audio track is not always at a predictable path across older and newer posts, which is exactly why so many hand-rolled downloaders return silent clips on some posts and correct ones on others.

The honest summary is that video is two downloads plus a mux, and there is no way around the split because it is how Reddit serves adaptive streaming. A media endpoint cannot make the audio and video one file for you at the CDN, but it can hand you the classified v.redd.it base and the is_video flag so your pipeline branches correctly, instead of you sniffing post_hint and domain yourself. For a longer discussion of when to build this versus buy it, the Reddit scraper build-versus-buy guide runs the tradeoff.

Galleries: resolving gallery_data into image URLs

Galleries are the other place the API surprises people, because a gallery post hides its images behind a metadata map instead of putting them in url. For a multi-image submission, is_gallery is true, url points at a https://www.reddit.com/gallery/<id> page, and the actual images are described by two fields: gallery_data.items, an ordered list of objects each carrying a media_id, and media_metadata, a map from each media_id to that image's type, dimensions, and hosted URLs on i.redd.it. To build the list of image links you walk gallery_data.items in order and look up each media_id in media_metadata. A media endpoint flags the post is_gallery: true and returns the gallery media_url, so you know to run the resolution step.

The pain is common enough that the "gallery URL is an HTML page, not an image" problem is a standing question about converting gallery URLs into image links in the community.

Laid out, the resolution is a small ordered join between the two fields.

The detail that trips people is ordering and format. The media_metadata map is keyed by media_id and is not ordered, so you must take the order from gallery_data.items, not from the map's key order, or the images come back shuffled. Each media_metadata entry also carries the mime type (m, for example image/jpeg) and a set of resized copies (p) plus the source (s), so you can pick the resolution you want the same way you do for a single image. Two more edges are worth knowing before you ship gallery handling. First, an individual gallery item can be a GIF or even an animated image, in which case its media_metadata entry has a different e type and its own URL fields, so branching only on "image" can drop a frame. Second, a gallery item that a moderator or the author removed shows up with a status other than valid, and you skip it rather than treating a missing URL as an error. A first-party kind=all search on 2026-08-02 returned a real gallery, "Alien space rock" in r/whatsthisrock, with media_url https://www.reddit.com/gallery/1v93535 and is_gallery: true, which is the flag that tells your code to run this join. This gallery-resolution pain is one of the most recurring questions in r/redditdev, and the comments endpoint uses a similar resolve-the-tree pattern for discussion data.

Filtering by media type: image, video, gallery, or all

When you only want one kind of media, you filter at the API instead of pulling everything and discarding most of it. The media endpoint takes a kind parameter with four values: kind=image returns only image posts, kind=video returns only Reddit-hosted videos, kind=gallery returns only multi-image galleries, and kind=all (the default) returns every media post mixed together. Under the hood the filter reads Reddit's own signals, matching post_hint == "image" for images, is_video or a hosted-video post_hint for videos, and is_gallery for galleries, so the classification is Reddit's, not a guess.

The four filters map to the four handling paths cleanly.

The practical value of filtering server-side is cost and clarity. If you are building an image dataset, kind=image means every returned post is directly downloadable and you never spend a branch on video muxing or gallery resolution. If you are collecting short clips, kind=video means every post is a v.redd.it base ready for the mux step. The default kind=all is right when you want the full media picture of a subreddit or query and will branch on kind per post anyway. Combine the filter with Reddit's search operators, covered in the advanced search filters guide, to scope by subreddit, author, or exact phrase before the media filter even runs.

Pulling Reddit media at scale for a dataset

Bulk media extraction is the reason a media endpoint earns its place: pulling one image is a curiosity, but pulling a labeled set of thousands is a real build. Reddit's images and videos have become a standard corpus for training and research, which is part of why access tightened in the first place, and the demand for structured media at scale has only grown.

Aakash Gupta

@aakashgupta

50% of all relationship advice on Reddit is “leave.” 15 years of data, 52 million comments, and the trend line only goes one direction. A researcher filtered r/relationship_advice down to 1,166,592 quality comments and tracked what people actually recommend. In 2010, “End https:… Show more

Reddit's usefulness as a data source is exactly why so much tooling now points at it, from research corpora to multimodal training sets.

Bearly AI

@bearlyai

Scott Alexander on AI agents emergent behaviour on Moltbook: “Reddit is one of the prime sources for AI training data. So AIs ought to be unusually good at simulating Redditors, compared to other tasks. Put them in a Reddit-like environment and let them cook, and they can https… Show more

The pattern for a dataset run is a metadata pass followed by a download pass. First you page through the media search collecting media_url, kind, and attribution for every post; then you download the files in a separate, parallelizable pass, sending images straight to disk, videos into the mux step, and galleries into the resolve step.

The pagination itself is a cursor loop. Each call returns an after value; you pass it back as after= on the next call to fetch the next batch, and you stop when the cursor stops advancing or you reach your target count. Splitting the metadata pass from the download pass matters because the two have different failure modes: the search calls are cheap reads you can retry freely, while the file downloads are large transfers you want to parallelize and resume. Keeping them separate means a failed download never forces you to re-run the search, and it lets you dedupe by media_url before spending any bandwidth. The pagination guide covers the cursor mechanics in full, including how it interacts with rate limits, and Reddit as a RAG data source covers feeding the results downstream.

What a media API costs, and its honest limits

Media search is priced like any other read, and it is honest about where the endpoint's job ends. A media search call is a standard read, billed around $0.002, the same tier as any other read request, and that covers the metadata pass that finds the posts and returns their media URLs. Downloading the actual image and video bytes from Reddit's CDN is a separate transfer that the API does not bill, because those bytes come straight from i.redd.it or v.redd.it. So the cost of a dataset run is roughly the number of search reads you make, not the size of the media you pull.

The cost is only half the picture; the limits matter just as much.

The honest limits are worth stating plainly. The endpoint returns media metadata and classification, not finished files: a video still needs the mux step to carry audio, and a gallery still needs the resolve step to become a list of images. Media search reads Reddit's current, reachable results, so it surfaces the media that a search returns rather than a full historical archive of everything ever posted. And over-18 content is excluded unless you opt in with nsfw=true, which keeps a default index safe but means you make that choice deliberately. None of this is hidden, because the response tells you the kind and the flags for every post.

One more limit is legal rather than technical, and it applies no matter how you pull the media: the images, videos, and galleries you fetch are user content served under Reddit's Data API Terms, and commercial or high-volume use is governed by them and by the guidance in Reddit's Data API Wiki. A managed API handles the access mechanics, but honoring the usage rules for the media you collect, and respecting the rights of the people who posted it, stays your responsibility. That matters most for dataset builds, where the temptation is to grab everything; scope the pull to what you actually need and keep the attribution the response already hands you. For a full cost comparison against running your own access or a general scraping platform, see the pricing guide and the pricing versus general scraping platforms breakdown.

What builders do with Reddit media

Media search is not an academic feature; it powers a specific set of real builds that text search cannot serve. The common thread is that the value is in the pixels and frames, not the title: the training corpus, the trend monitor, the archive, and the moderation model all need the actual media, structured and at scale. Being able to pull images, videos, and galleries by query, filtered by type, turns a set of subreddits into a queryable media source.

The recurring use cases cluster into a handful of patterns.

• Dataset building: pull labeled image or video sets from topic-specific subreddits for training
• Trend and brand monitoring: watch for images and clips mentioning a product or logo
• Archival and backup: capture a subreddit's media before posts age out or get removed
• Multimodal AI context: feed images and video frames into a model alongside the discussion
• Content aggregation: build a themed feed of the top visual posts across communities

Dataset building is the heaviest user, because a media endpoint with a kind filter and pagination is exactly the shape a training pipeline wants. Trend monitoring watches for a logo or product in images and clips, not just in text. Archival captures a community's visual history before removal or decay takes it. Multimodal AI feeds the media alongside the comments so a model reasons about the whole post, which is the same job the Reddit API for AI agents guide covers on the text side. And aggregation builds a themed visual feed from the best posts across a set of subreddits, which starts with finding the right subreddits in the first place.

When you need something else, and the next step

Media search covers images, videos, and galleries, but it is not the answer to every Reddit-data question, and being honest about the edges saves you from forcing the wrong tool. If you want the text of a discussion rather than its media, that is post search or the comment search endpoints. If you already know a post and want its full comment tree, that is the comments endpoint. If you need a full historical archive of everything ever posted rather than what a search surfaces now, an archive like the ones covered in best Pushshift alternatives is the better fit. And if raw scraping is where you started, the death of the free JSON endpoint explains why the managed path keeps winning.

For the job this guide is about, fetching Reddit images, videos, and galleries by query over live data, a managed REST media endpoint is the path that handles all three shapes without you writing separate logic for each.

• Read the Reddit data API guide for the full access picture
• Compare the paths in dollars in the pricing guide
• Get an API key to test /search/media directly, with free credit at signup

Need to pull Reddit images, videos, and galleries, not just text? redditapis.com gives you media search behind one bearer token: GET /search/media with a kind filter for images, videos, or galleries, a clean media_url per post, and pagination for dataset-scale pulls. See pricing or get an API key with free credit at signup to fetch the media Reddit's raw JSON makes you resolve by hand.