Buying a podcast dataset: what is in it, what it costs, and how to judge quality

Podcasts are one of the largest bodies of public media that almost nobody analyzes systematically. There are millions of shows, each publishing structured metadata in an RSS feed, yet most market researchers, sales teams and academics still work from top-100 charts or hand-built spreadsheets. A good podcast dataset changes that: it lets you count, segment and contact a market instead of guessing at it.

This guide is for people buying podcast data for the first time, or replacing a source that no longer fits. It covers where podcast data comes from, which fields matter, how to define a useful slice, how to judge quality before you rely on it, and what a dataset from podsearch.org contains and costs.

Where podcast data comes from

Almost all podcast data originates in the same place: the show's RSS feed. A feed is an XML document, hosted by the podcaster or their hosting platform, that lists the show's title, description, artwork, author, categories, language, owner contact, and every episode with its title, description, publish date, duration and audio URL. Directories like Apple Podcasts and Spotify read these feeds; so does every podcast data provider.

What differs between providers is:

• Which feeds they know about. podsearch.org is built on the Podcast Index, an open catalog of about 4.7 million RSS feeds. About 3.2 million active feeds are parsed into episodes.
• How often they re-read feeds. podsearch.org re-polls feeds within seconds to minutes when a host sends a Podping notification, and on an adaptive schedule otherwise.
• What they derive. Raw feeds do not say how often a show publishes, whether it is still active, or whether it is a video podcast. Providers compute these from the episode history.
• What they add from elsewhere. Some vendors estimate audience size or attach social profiles. Those estimates are modeled, not read from the feed, and you should treat them accordingly.

Understanding this chain matters because it tells you what can and cannot be true in any dataset. A field that is not in the feed and is not derived from it has to come from somewhere else, and you should ask where.

The fields that matter

A podcast dataset is typically one row per show. These are the fields in a podsearch.org CSV export and what each is good for.

A few notes from experience:

Activity fields are the most underrated. The single most common mistake in podcast research is treating every feed as a live show. A large share of the catalog is dormant: shows that published a few episodes and stopped. latest_pub_date and episode_count let you separate active shows from abandoned experiments in one filter.

email is the publisher's own published contact. It comes from the owner email that many feeds include for directory verification. It is not present in every feed, it may be a shared or agency inbox, and its use for outreach is subject to the law where you and the recipient are. More on that in our lead list guide.

AI labels are partial by design. podsearch.org classifies shows on demand with an LLM and labels a show "likely AI" only at 0.9 confidence or above. An empty value means the show has not been judged yet, not that it was judged human-made.

Defining your slice

Nobody needs all 4.7 million feeds. The value of a dataset comes from a precise slice. On the datasets page you can filter by:

• Category, such as Business, Health & Fitness or True Crime, combining several.
• Language, one or more.
• Hosting platform, recognized from the feed URL. The list includes Spotify/Anchor, Buzzsprout, Podbean, Libsyn, Spreaker, SoundCloud, Megaphone, Simplecast, Transistor, Captivate, Acast, Omny Studio, Blubrry, RedCircle and others.
• Episode count range, to exclude tiny or one-off feeds.
• Latest and earliest publish dates, to select active shows, new launches or long-running ones.
• Explicit flag.
• Has email, to keep only shows with a published contact.

The page shows a live count and a sample of matching shows as you filter, so you can see the effect of each constraint before paying.

Three example slices

"Active English-language business podcasts." Category Business, language English, latest episode in the last 90 days, at least 20 episodes. This is a typical sponsorship or guest-booking universe.

"New shows launched this year on a given host." Hosting platform of interest, earliest publish date after January 1, at least three episodes. Hosting companies and podcast tool vendors use slices like this to study new creators.

"Long-running Spanish-language health shows with a contact." Category Health & Fitness, language Spanish, earliest publish date more than two years ago, has email. Useful for partnerships in a specific market.

How to judge quality before you rely on it

Any dataset of millions of self-published feeds will contain errors, because publishers make mistakes. The question is whether the provider lets you see and handle them. Run these checks on any podcast dataset, ours included.

1. Spot-check against the source

Pick 20 random rows and open each rss_url. Does the title match? Is the latest episode date right? Is the episode count in the right range? Because every podsearch.org row includes the feed URL, you can always verify against the original.

2. Check activity distributions

Plot latest_pub_date by month. You should see a large spike of recently active shows and a long tail of dormant ones. If a dataset claims almost everything is active, its activity data is suspect.

3. Look for duplicates

Shows that move between hosting platforms sometimes leave the old feed alive. Group by normalized title plus author and inspect the groups. Decide whether to keep the most recently updated feed.

4. Inspect categories and languages

Publishers choose their own categories and language codes, and some choose badly: a business show tagged as Comedy, or an English show declared as en-us, en-GB or nothing at all. Normalize language codes to their first two letters before counting.

5. Check what is modeled

If a dataset includes audience sizes, ask how they are estimated. podsearch.org does not estimate audience size; everything in the export is either read from the feed, derived from the episode history, or a labelled classifier output.

What it costs

podsearch.org datasets are priced per podcast, one-time, paid through Stripe. The rate depends on the size of the order:

There is a $60 minimum order. The per-podcast rate applies to the whole order. Some worked examples:

• 300 shows: 300 × $0.10 = $30, so the $60 minimum applies.
• 800 shows: 800 × $0.10 = $80.
• 2,500 shows: 2,500 × $0.08 = $200.
• 6,000 shows: 6,000 × $0.05 = $300.
• 25,000 shows: 25,000 × $0.03 = $750.

Note the tier boundaries: 1,000 shows at $0.08 is $80, less than 999 shows at $0.10. If you are close to a boundary, widening your filter slightly can lower the price.

For comparison, many podcast research tools are sold as monthly subscriptions with export limits rather than per-row purchases. For example, Rephonic's web app lists Light, Standard and Business plans at $99, $149 and $299 a month (pricing, as of October 2026), with features such as audience estimates and contact finding that a feed-based dataset does not provide. Subscription tools suit ongoing prospecting; a one-time export suits analysis, enrichment and one-off campaigns.

Working with the export

The export is a standard UTF-8 CSV. A few practical tips:

import pandas as pd

df = pd.read_csv("podcast-dataset.csv", parse_dates=["latest_pub_date", "earliest_pub_date"])
df["lang2"] = df["language"].str[:2].str.lower()
df["active_90d"] = df["latest_pub_date"] >= pd.Timestamp.utcnow().tz_localize(None) - pd.Timedelta(days=90)
df["age_years"] = (pd.Timestamp.utcnow().tz_localize(None) - df["earliest_pub_date"]).dt.days / 365

print(df.groupby("lang2")["active_90d"].mean().sort_values(ascending=False).head(10))
print(df[["episode_count", "update_frequency_hours", "avg_audio_length_sec"]].describe())

• Descriptions contain HTML. Strip tags before text analysis.
• Categories may hold several values. Split them before counting, or a show in two categories will look like a new category.
• Keep feed_id. It is your key for refreshing the data later or joining to API results.

If you need ongoing updates rather than a snapshot, combine a dataset export with the podsearch.org API, which can refresh individual shows by ID.

Common uses, by team

The same export serves very different jobs. Knowing which one you are doing helps you choose filters and fields.

Market research and strategy. Count shows by category, language and activity to size a niche, compare growth across markets with earliest_pub_date, and track how many new shows launch each month. Fields that matter: categories, language, earliest_pub_date, latest_pub_date, episode_count.

Sales and partnerships. Build target lists of active shows in a vertical, segmented by publishing cadence and format. Fields that matter: title, author, website, email, update_frequency_hours, avg_audio_length_sec.

Product and competitive analysis. Hosting platforms, tool vendors and networks study creators by platform, size and tenure. The hosting platform filter and rss_url are the key inputs.

Academic research. Researchers draw samples to study topics, languages, formats and the dynamics of a self-published medium. The stable feed_id and rss_url make samples reproducible and auditable. See our guide to podcast data for academic research.

Brand safety and content teams. The explicit flag and the AI classifier fields help screen lists before outreach or ad buying, as one input among several.

Keeping a dataset fresh

A CSV export is a snapshot. Podcasts launch, stop and change hosts every day, so plan how you will refresh it.

• Re-export periodically. For market sizing, a quarterly export is usually enough. Re-run the same filters and compare counts.
• Refresh individual rows. For an active outreach list, refresh the shows you care about through the API by feed_id, which returns current episode counts and latest publish dates.
• Diff by key. Join old and new exports on feed_id to find shows that went dormant, new shows that entered your criteria, and shows whose contact or website changed.

old = pd.read_csv("q2.csv").set_index("feed_id")
new = pd.read_csv("q3.csv").set_index("feed_id")
entered = new.index.difference(old.index)
left = old.index.difference(new.index)
print(len(entered), "shows entered the slice;", len(left), "left it")

Tracking entries and exits over time is itself a valuable dataset: it tells you whether a niche is growing, consolidating or fading.

A short buying checklist

Before you check out, confirm five things: the filters match your written definition; the live count is in the range you expected (a count far above it usually means a filter is too broad); the sample rows look like the shows you want; you know which fields you will actually use; and you have a plan for refreshing the data. Ten minutes on this list saves buying the wrong slice twice.

Frequently asked questions

How many podcasts are in the catalog?

The underlying Podcast Index catalog contains about 4.7 million RSS feeds, of which around 3.2 million active feeds are parsed into episodes. Your slice will be much smaller once you filter for language, category and activity.

Do datasets include listener numbers?

No. podsearch.org does not estimate audience size. Exports include feed metadata, derived activity and format fields, and classifier labels where available.

Are contact emails included?

Where the feed publishes an owner email, yes, and you can filter to shows that have one. Use contacts in line with the anti-spam and data-protection laws that apply to you and to the recipients.

Can I preview the data before buying?

Yes. The datasets page shows the number of matching podcasts and a sample of rows as you adjust filters, before checkout.

Is it a subscription?

No. Each dataset is a one-time purchase through Stripe, priced per podcast with a $60 minimum.

Can I use the data commercially?

The data is drawn from public RSS feeds, and many buyers use it for market research, sales and partnerships. Review the terms that come with your purchase and the laws that apply to your use, especially for personal data such as contact emails.

Summary

A podcast dataset is only as useful as the slice you define and the checks you run. Know where each field comes from, filter hard on activity, verify against the RSS feeds, and treat modeled numbers with care. With a clean, well-defined slice of the 4.7-million-feed catalog, you can size markets, find partners and study the medium with evidence instead of charts alone.