VidRock APIvidrock.to ↗
Access VidRock player data via API: per-provider stream availability and subtitle tracks for movies and TV episodes, identified by TMDB id.
What is the VidRock API?
The VidRock API exposes 4 endpoints covering stream provider availability and subtitle track listings for movies and TV episodes from the VidRock (vidrock.to) embed player. The get_movie_sources endpoint returns a row for each of five named providers — Nova, Atlas, Luna, Orion, and Astra — indicating whether a stream is currently available, along with an opaque stream reference and stream type. Companion subtitle endpoints return WebVTT track URLs and player menu labels drawn from two independent subtitle catalogs.
curl -X GET 'https://api.parse.bot/scraper/92a4c5f5-b3f7-400d-8e5b-e0c7efee4230/get_movie_sources?tmdb_id=533535' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace vidrock-to-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: VidRock SDK — stream sources and subtitles for movies and TV."""
from parse_apis.vidrock_to_api import VidRock, SubtitleCatalog, InputFormatInvalid
client = VidRock()
# Fetch stream provider table for a movie (Deadpool & Wolverine).
movie = client.movies.get(tmdb_id="533535")
print(f"Movie TMDB {movie.tmdb_id}: {movie.available_count} providers available")
if movie.sources:
for src in movie.sources:
if src.available:
print(f" {src.provider}: {src.stream_type}, {src.language}")
# List curated (v2) subtitles for the same movie.
for sub in movie.list_subtitles(catalog=SubtitleCatalog.V2, limit=5):
print(f" subtitle: {sub.label} -> {sub.file_url}")
# Fetch stream provider table for a TV episode (Game of Thrones S1E1).
episode = client.episodes.get(tmdb_id="1399", season=1, episode=1)
print(f"\nTV TMDB {episode.tmdb_id} S{episode.season}E{episode.episode}: "
f"{episode.available_count} providers available")
if episode.sources:
for src in episode.sources:
if src.available:
print(f" {src.provider}: {src.stream_type}, {src.language}")
# List legacy (v1) subtitles for the episode.
for sub in episode.list_subtitles(catalog=SubtitleCatalog.V1, limit=5):
print(f" subtitle: {sub.label} -> {sub.file_url}")
# Demonstrate typed error handling for an invalid TMDB id format.
try:
client.movies.get(tmdb_id="tt4154796")
except InputFormatInvalid as e:
print(f"\nExpected error for IMDb-style id: {e.message}")
print("\nexercised: movies.get / episodes.get / list_subtitles (v1 + v2) / InputFormatInvalid")
Returns the provider table the VidRock player consults for one movie: one row per named stream provider (five providers were observed: Nova, Atlas, Luna, Orion, Astra) with whether that provider currently has a stream, the opaque encoded stream reference the player passes on, the stream type (hls) and audio language. Providers with no stream have available=false and null fields. One round trip. The site answers for any numeric id, including ids it does not know (typically only one generic provider row is then marked available), so available_count is the meaningful signal. A non-numeric id (e.g. an IMDb tt-id) is rejected with a stale_input envelope; the site itself only accepts numeric TMDB ids on this route.
| Param | Type | Description |
|---|---|---|
| tmdb_idrequired | string | TMDB movie id, digits only (e.g. 533535). IMDb ids are not accepted. |
{
"type": "object",
"fields": {
"sources": "array of provider rows: provider (name), available (boolean), stream_reference (opaque encoded token or null), stream_type (\"hls\" or null), language (audio language or null), flag (country code or null)",
"tmdb_id": "the requested TMDB id as a string",
"media_type": "always \"movie\"",
"available_count": "integer number of providers with available=true"
},
"sample": {
"data": {
"sources": [
{
"flag": "us",
"language": "English",
"provider": "Nova",
"available": true,
"stream_type": "hls",
"stream_reference": "ipCq5FSxY_WKn03zx_lQv9VAJ2dtFY3k1ae9s7c66h1wjqQjAb5uoc3AZcH6mrsQSLWM_13606uSxl3v_sZVfMp0MmBisUMLvW4o5iJ8gW7RJCB8UUDgPbe3YFWMWGox9ZGiZSjehCRKt-vVrGD4DCbTcvy0OENzD0M"
},
{
"flag": null,
"language": null,
"provider": "Astra",
"available": false,
"stream_type": null,
"stream_reference": null
}
],
"tmdb_id": "533535",
"media_type": "movie",
"available_count": 4
},
"status": "success"
}
}About the VidRock API
Stream Source Endpoints
get_movie_sources and get_tv_episode_sources both return a sources array, one entry per provider. Each entry includes provider (name), available (boolean), stream_reference (an opaque encoded token, or null when unavailable), and stream_type (e.g. "hls"). The response also includes tmdb_id, media_type, and available_count — the integer count of providers with available: true. The TV episode variant requires tmdb_id, season, and episode as inputs; season and episode numbers follow TMDB's 1-based numbering. Only TMDB ids are accepted — IMDb ids are not.
Subtitle Endpoints
list_movie_subtitles and list_tv_episode_subtitles return a subtitles array where each entry contains a label (the text shown in the player's subtitle menu, sometimes with a variant suffix or duplicate index) and a file_url pointing to the WebVTT file the player loads. Both endpoints accept an optional catalog parameter (v1 or v2) to select between the two subtitle catalogs VidRock maintains; the response echoes back which catalog was read. The subtitle_count field gives the number of tracks returned.
Scope and Identifiers
All four endpoints are keyed on TMDB ids only. Movie endpoints take a tmdb_id string (digits only, e.g. 533535). TV endpoints additionally require integer season and episode parameters. The site's catalog listing endpoints (/list/movie.json, /list/tv.json) are not exposed — there is no bulk enumeration of available titles through this API. Provider names observed across endpoints are Nova, Atlas, Luna, Orion, and Astra; the set of active providers and their availability can vary per title.
The VidRock API is a managed, monitored endpoint for vidrock.to — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when vidrock.to changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official vidrock.to API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Check which of the five VidRock providers (Nova, Atlas, Luna, Orion, Astra) currently have a stream available for a given movie before surfacing it to users
- Fetch stream references for a specific TV episode using TMDB show id, season, and episode number to build a provider-availability dashboard
- Retrieve WebVTT subtitle URLs for a movie or episode to pre-load or cache subtitle files keyed on TMDB id
- Compare subtitle track counts across the two VidRock catalogs (v1 vs v2) for the same title to identify which catalog has broader language coverage
- Monitor
available_countacross a list of TMDB ids to track how many providers are active for a title over time - Pull subtitle
labelvalues to display available language options for a title before the player is loaded
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does VidRock provide an official developer API?+
/movie/{tmdb_id}, /tv/{tmdb_id}/{season}/{episode}) with parameters like autoplay, lang, and theme, but those are player embeds, not data endpoints.What does the `stream_reference` field in the sources response contain?+
available: true. Its structure is intentionally undocumented; it is null when the provider has no stream for that title. The field is present for all five providers in every response regardless of availability.Can I look up titles by IMDb id instead of TMDB id?+
Does the API expose a full catalog of titles available on VidRock?+
/list/movie.json and /list/tv.json catalog files currently return a 404 and are not exposed. You can fork this API on Parse and revise it to add a catalog enumeration endpoint if those listing files become available.Are there two separate subtitle catalogs, and do they return different tracks?+
catalog parameter (v1 or v2) on both subtitle endpoints. The two catalogs can return different track sets for the same title — different languages, label variants, or track counts. If catalog is omitted, the API reads a default catalog and echoes back which one was used in the catalog response field.