Rotten Tomatoes API: 6 Ways to Get Tomatometer Data in 2026

You find an old Stack Overflow answer. It tells you to grab a free key from the Rotten Tomatoes developer portal. You go looking for that portal and find no signup button anywhere.

Meanwhile your movie app, your watchlist, or your AI agent still needs real Tomatometer scores. So you search for a rotten tomatoes api and land on GitHub repos from 2014 and a Reddit thread with no clear answer.

Sound familiar? We dug through every option so you don't have to.

Does Rotten Tomatoes Have an API? The Short Answer

No, Rotten Tomatoes does not offer a public, self-serve API in 2026. The official route runs through a business proposal on the Rotten Tomatoes licensing page, or through Fabric's Origin platform, which needs an approved account and a paid subscription.

Everyone else uses an unofficial Rotten Tomatoes API or a scraper. That is not a bad thing. Some of the unofficial options give you more data than the old public API ever did, including TV episode scores and celebrity filmographies.

So the real question is not "does it exist?" It is "which option fits my project and my budget?" Let's answer that.

TL;DR: 6 Rotten Tomatoes API Options at a Glance

If you only have 30 seconds, here is the list.

• API.market Rotten Tomatoes API (by proapi): 15 endpoints for movies, TV seasons, episodes and celebrities. Free 7-day trial with 100 calls, then $0.001 per successful call.
• Official Rotten Tomatoes API (Fandango / Fabric): partner-only access through a licensing review. Pricing is not public.
• RottenTomato API on RapidAPI (by apiguru): monthly plans from $4.99, plus a free plan capped at 5 requests a day.
• Apify Rotten Tomatoes Actor (by superapis): $1.00 per 1,000 requests, plus Apify platform usage.
• OMDb API: free key with 1,000 requests a day. Returns the Tomatometer percentage for movies, nothing more.
• Open-source scrapers: free Python libraries that break when the site changes.

Now the full breakdown.

Rotten Tomatoes API: Why Developers Still Need One

Rotten Tomatoes scores show up everywhere. You see them on streaming apps, in movie newsletters, on trailer pages, and in the "should I watch this?" debates your friends have every Friday.

If your product talks about movies or TV, people expect to see that red tomato or green splat next to the title.

Rotten Tomatoes API Use Cases for Apps and AI Agents

Here is where teams actually use this data:

• Movie and TV review sites show the Tomatometer, audience score and Certified Fresh status next to their own reviews.
• Streaming and watch guides pair scores with "where to watch" links, so users pick something good on the service they already pay for.
• Recommendation and watchlist apps rank titles by critic or audience score and suggest what to watch next.
• Entertainment newsrooms track new releases and their latest scores for weekend roundups.
• AI agents and chatbots ground answers in real scores. Without an API, a language model will happily invent a 94% for a movie that sits at 41%.

That last one matters more every month. You know how often LLMs get a number almost right? An API call fixes that.

What Happened to the Official Rotten Tomatoes API

Rotten Tomatoes used to run a key-based public API at developer.rottentomatoes.com. You can still see traces of it. The Go package rojters/rottentomatoes, published in June 2014, wraps that old API and reads your key from a ROTTENTOMATOES_APIKEY variable.

By 2021, a developer blogging as zverok wrote that the official API had gone invite-only, and he pulled RT scores out of Wikipedia articles instead. That workaround tells you how hard the official door had become.

Today, the Rotten Tomatoes licensing page asks you to submit a Business Proposal Form if you want to integrate their data "via APIs, data feeds." Their team reviews it and decides. Fabric's knowledge base describes the same data (Tomatometer, Audience Scores, critic snippets, Certified Fresh titles), but only for approved developer accounts with a paid Origin subscription.

Rotten Tomatoes Scores Explained: What Your API Returns

Before you pick an API, know what the numbers mean. People search "what is a good Rotten Tomatoes score" all the time, and your users will ask the same thing.

The definitions below come straight from the Rotten Tomatoes About page.

Top 6 Rotten Tomatoes API Options in 2026

1. API.market Rotten Tomatoes API (by proapi)

The API.market Rotten Tomatoes API returns movie, TV and celebrity data across 15 GET endpoints, with a free 7-day trial (100 calls) and pay-as-you-go pricing of $0.001 per successful call.

This is the most complete unofficial Rotten Tomatoes API we found. It covers critic and audience scores on movies, TV shows, individual seasons and individual episodes. It also returns cast and crew, trailers, photo galleries, where-to-watch links and celebrity filmographies.

One thing to know upfront. This is an independent API that returns publicly visible data from Rotten Tomatoes pages. Rotten Tomatoes and Fandango do not run it or endorse it, and the listing says so clearly.

Key features:

• 15 GET endpoints for search, browse lists, movie details, TV details, seasons, episodes, cast and crew, videos, pictures and celebrities, all returning JSON.
• Full score objects. criticsScore carries the Tomatometer, average rating, sentiment, review count and certified flag. audienceScore carries the score, sentiment, liked count and review count.
• One search for everything. /v1/search returns matching movies, TV series and celebrities in a single call, each with a slug.
• Browse lists with filters. /v1/browse/list covers movies in theaters, movies at home, coming soon and TV series, filtered by genre, MPAA rating, critic band, audience band and streaming service, with cursor pagination.
• Season and episode scores. /v1/tv/season and /v1/tv/episode give you per-season scores, episode lists, air dates, directors, writers and cast.
• Slug chaining and source links. Every object carries a Rotten Tomatoes slug and the original page URL, so one search result leads to details, cast, videos and pictures.

That source URL helps more than you might think. The Rotten Tomatoes licensing page says any use of their scores needs brand attribution and a link back to the movie page. With this API, the link sits right there in every response.

Pricing is simple. The Free plan gives you a 7-day trial with 100 API calls at up to 10 requests per second, enough to test every endpoint. After that, you switch to pay as you go at $0.001 per successful call, with no monthly fee and a $1.00 minimum wallet balance. That works out to $1 for every 1,000 successful calls, at up to 300 requests per second.

You only pay for 2xx responses. If you look up a slug that does not exist, the API returns a 404 and API.market does not bill you for it.

Here is what a real call looks like:

curl -X GET "https://prod.api.market/api/v1/proapi/rotten-tomatoes/v1/movie/details?slug=toy_story_5" \
  -H "x-api-market-key: YOUR_API_KEY"

And here is the part of the response you probably care about most (abridged from the API docs):

{
  "title": "Toy Story 5",
  "url": "https://www.rottentomatoes.com/m/toy_story_5",
  "criticsScore": {
    "score": 92,
    "averageRating": "7.80",
    "sentiment": "POSITIVE",
    "reviewCount": 329,
    "certified": true
  },
  "audienceScore": {
    "score": 94,
    "sentiment": "POSITIVE",
    "likedCount": 10012,
    "reviewCount": 2193,
    "certified": true
  }
}

Want it in Python? Search by title first, then pass the slug to the details endpoint.

import requests
BASE = "https://prod.api.market/api/v1/proapi/rotten-tomatoes"
HEADERS = {"x-api-market-key": "YOUR_API_KEY"}
hits = requests.get(f"{BASE}/v1/search", params={"q": "interstellar"}, headers=HEADERS).json()
slug = hits["movies"][0]["slug"]
movie = requests.get(f"{BASE}/v1/movie/details", params={"slug": slug}, headers=HEADERS).json()
print(movie["title"], movie["criticsScore"]["score"], movie["audienceScore"]["score"])

Real use cases:

Say you run a movie review blog. Every post needs the current Tomatometer, the audience score and a Certified Fresh badge. You call /v1/movie/details when the page builds, cache the result for a day, and link the score back to Rotten Tomatoes. Your readers always see fresh numbers and you never copy them by hand.

Now say you build a streaming guide. A user wants "Certified Fresh comedies on Netflix right now." You call /v1/browse/list with type=movies_at_home, genres=comedy, critics=certified_fresh and affiliates=netflix. That is one request, and you get a ranked list ready for your UI.

Or you ship an AI movie assistant. A user asks whether season 2 of a show holds up against season 1. Your agent calls /v1/tv/season twice and compares the two criticsScore objects, so the answer comes from real data.

API.market also offers an MCP connection, so you can plug this API into an agent without writing a wrapper.

Who should skip it? If you need a signed license to display Rotten Tomatoes branding inside a big commercial product, talk to Rotten Tomatoes directly first.

2. Official Rotten Tomatoes API (Fandango and Fabric)

The official Rotten Tomatoes API is partner-only in 2026. You apply through a Business Proposal Form or through Fabric Origin, and pricing is not public.

This route fits large companies that need a formal license. Fabric's docs list endpoints for movies, shows, seasons and episodes, where you pass an Origin ID and get back Rotten Tomatoes reviews or ratings.

Key features:

• Tomatometer, Audience Scores, critic snippets and critics consensus
• "Critically Acclaimed" (Certified Fresh) titles, promotions and analytics
• Lookups by Origin Movie, Show or Season ID
• Use falls under the Fandango API License Terms and Rotten Tomatoes brand guidelines

Neither company lists a price publicly. Fabric requires an approved developer account plus a paid subscription to one of its core Origin solutions, and Rotten Tomatoes reviews every request before it grants access.

Real use cases:

You run a smart TV platform and want the Tomatometer on every title tile, with full legal cover. The official license is the right call, even with a long sales cycle.

You are a solo developer or a startup testing an idea this week. This route will not fit your timeline.

3. RottenTomato API on RapidAPI (by apiguru)

The RottenTomato API on RapidAPI is a third-party Rotten Tomatoes API with a free plan of 5 requests a day and paid monthly plans from $4.99.

It sits in RapidAPI's Rotten Tomatoes collection, the same collection page that ranks on Google for this keyword. The listing promises movie reviews, critic and audience ratings, cast and crew, trailers, posters and images.

Key features:

• Critic and audience ratings for movies and TV
• Cast and crew details, trailers and posters
• RapidAPI's shared dashboard, SDK snippets and billing
• Rate limits from 2 to 15 requests per second, depending on plan

The Basic plan costs nothing but stops hard at 5 requests a day. Pro costs $4.99/month for 11,500 requests, Ultra costs $19.99/month for 75,000 requests, and Mega costs $95.99/month for 350,000 requests. Overage runs $0.01, $0.005 and $0.001 per extra request on those three plans, and RapidAPI adds a bandwidth fee of $0.001 per MB after 10,240 MB a month.

Real use cases:

You run a steady, predictable workload every month. A fixed plan lets you budget ahead of time. You already manage several APIs inside RapidAPI. Adding one more keeps your billing in one place.

4. Apify Rotten Tomatoes Actor (by superapis)

The Apify Rotten Tomatoes actor is an HTTP JSON API that costs $1.00 per 1,000 requests, plus Apify platform usage while it runs.

It runs in Apify's Standby mode, so each GET request returns JSON directly. You do not start a scraping run and then poll for a dataset, which is how most Apify actors work.

Key features:

• Titles, critic and audience scores
• Cast and crew, seasons and episodes
• Videos, pictures and posters
• Search and browse results
• No charge for failed or invalid requests

Pricing is pay per request at $1.00 per 1,000 API requests, no matter how much data comes back. On top of that, Apify bills your account for platform usage while the actor stays awake. You need an Apify account to use it.

Real use cases:

Your team already runs scrapers on Apify. Adding Rotten Tomatoes data to the same account keeps everything in one dashboard.

You need a one-off data pull for a research project and want per-request billing without a subscription.

5. OMDb API (Tomatometer Only)

OMDb is a free movie database API (1,000 requests a day) that includes the Rotten Tomatoes Tomatometer percentage inside its Ratings array for many movies.

To be clear, OMDb is not a Rotten Tomatoes API. It is a general movie API that happens to return a line like {"Source": "Rotten Tomatoes", "Value": "83%"}. For a lot of side projects, that one number is enough.

Key features:

• Search by title or IMDb ID
• Ratings array with IMDb, Rotten Tomatoes and Metacritic values
• Plot, cast, runtime, genre and poster URL (posters for patrons only)
• Free key signup in minutes
• 
  

The free key gives you 1,000 requests a day. OMDb also offers paid Patreon memberships for higher limits and the Poster API. Note the content license too: OMDb lists its content under CC BY-NC 4.0, which restricts commercial use.

Know the limits before you build on it. You get no audience score, no Certified Fresh flag and no TV season or episode scores. A GitHub issue on the OMDb repo also shows the older tomatoMeter fields returning "N/A" even when the Ratings array has a value.

Real use cases: You build a personal movie tracker and only want the Tomatometer next to each title. OMDb's free tier covers it. You run a non-commercial class project on film ratings. One free key and you are done.

6. Open-Source Rotten Tomatoes Scrapers (Python)

Open-source Rotten Tomatoes scrapers are free Python libraries, but they rely on the site's pages or hidden endpoints and break when those change.

Two show up on page one of Google. jaebradley's rotten_tomatoes_client calls the endpoints the author found in browser network traffic. rottentomatoes-python on PyPI scrapes the site directly, and its latest release (v1.2.0) came out in September 2024.

Key features:

• Free to install with pip
• Tomatometer, audience score, genres, rating and actors (rottentomatoes-python)
• Search plus movie and TV browsing with filters (rotten_tomatoes_client)
• Full control over caching and storage

Pricing is $0 for the code. You still pay in time: hosting, proxies if you scale, and fixes every time Rotten Tomatoes updates its pages. The rotten_tomatoes_client README says it plainly: "there are no guarantees about the reliability of this client."

Real use cases: You want to learn how scraping works, or you run a weekend script for a few hundred titles. A library is fine. You plan to ship a production app. Expect breakage, and keep a managed API as your fallback.

Rotten Tomatoes API Pricing Overview

Here is the fast version of what each option costs as of October 2026.

• API.market Rotten Tomatoes API: free 7-day trial with 100 calls, then $0.001 per successful call with no monthly fee.
• Official Rotten Tomatoes API: partner licensing, pricing not public.
• RapidAPI RottenTomato: free at 5 requests a day, paid plans from $4.99/month.
• Apify Rotten Tomatoes actor: $1.00 per 1,000 requests plus Apify platform usage.
• OMDb API: free key with 1,000 requests a day, Patreon tiers for more.
• Open-source scrapers: free code, your own hosting and maintenance.

How to Choose the Right Rotten Tomatoes API

Ask yourself four questions before you write any code.

• Do you need TV seasons, episodes or celebrity data? Pick API.market or the Apify actor. OMDb and most scrapers stop at movies.
• Do you need the audience score, not just the Tomatometer? Skip OMDb. API.market returns both in separate objects with review counts.
• Is your traffic spiky or small? Pay-per-call pricing means you never pay for unused quota. If you run a steady, very high volume every month, do the math on a fixed plan too.
• Do you need a formal license for big commercial use? Start the official proposal with Rotten Tomatoes, and use an unofficial API to build and test while you wait.

Whatever you pick, follow the Rotten Tomatoes rule: show the brand and link each score back to its page. It keeps your users informed and keeps you on the right side of their guidelines.

Which Rotten Tomatoes API Should You Use?

For most developers, start with the API.market Rotten Tomatoes API.

You get 15 endpoints that cover movies, TV shows, seasons, episodes and celebrities. You get full criticsScore and audienceScore objects, a source URL on every result for easy attribution, and up to 300 requests per second. You pay $0.001 per successful call with no monthly fee, and 404s cost nothing.

If you only need one Tomatometer number for a hobby project, OMDb's free key works. If you sign a big streaming or hardware deal, the official license route makes sense.

For everyone else, grab an API.market key, run the free trial this week, and see how the Rotten Tomatoes API feels in your code.

Try it here: https://api.market/store/proapi/rotten-tomatoes

FAQs About the Rotten Tomatoes API

1. Does Rotten Tomatoes have an API?

Rotten Tomatoes does not have a public, self-serve API in 2026. Official access goes through a Business Proposal Form on the Rotten Tomatoes licensing page or through Fabric Origin, which needs approval and a paid subscription. Most developers use an unofficial Rotten Tomatoes API, such as the one on API.market, which returns critic and audience scores through simple GET requests.

2. How do I get a Rotten Tomatoes API key?

You cannot get an official Rotten Tomatoes API key without a partner agreement, because Rotten Tomatoes closed public key signups years ago. To get started today, sign up on API.market, subscribe to the Rotten Tomatoes API, and send your API.market key in the x-api-market-key header. The free trial includes 100 calls.

3. Is there a free Rotten Tomatoes API?

Yes, a few free options exist, but each one has limits: the API.market Rotten Tomatoes API offers a free 7-day trial with 100 calls, and RapidAPI's RottenTomato has a free plan capped at 5 requests a day. OMDb gives 1,000 free requests a day but returns only the Tomatometer for movies. Open-source scrapers cost nothing but break often.

4. What is a good Rotten Tomatoes score?

A good Rotten Tomatoes score is anything at 60% or higher, because that makes a title Fresh. Certified Fresh needs at least 75%, five Top Critic reviews and a minimum review count. On the audience side, Verified Hot needs a verified audience score of 90% or higher.

5. How do I use the Rotten Tomatoes API in Python?

To use the Rotten Tomatoes API in Python, send GET requests with the requests library. Call /v1/search with a title to get a slug, then pass that slug to /v1/movie/details or /v1/tv/details with your x-api-market-key header. The JSON response includes criticsScore and audienceScore objects you can read directly.