Automating Film Search with Postman and Watchmode API

With so many streaming services and so much content, it’s getting harder to keep track of what’s available where. Sure, some sites will tell you which platform a specific movie or show is on—but what if you don’t know exactly what you want to watch?

That was my dilemma recently. I wanted to watch something with Jason Statham, but I wasn’t sure which film I was in the mood for. I just wanted to see what was available across my subscriptions and choose from there. In my house we have Amazon Prime, Netflix, and Disney+, and the thought of searching each one manually sounded painful.

So… I automated it.

Using a Postman collection and a Watchmode API key, I built a small platform-agnostic search tool that pulls together every Statham title and tells me where I can stream it. Watchmode’s data isn’t perfect, but it’s reliable enough for casual browsing, and the API is so simple that you can be up and running in minutes.

The Watchmode API Requests

1. Make a request to the ‘search’ endpoint with the name of the actor you’re interested in to get their Watchmode id:
   https://api.watchmode.com/v1/search/?apiKey={{api_key}}&search_field=name&search_value={{actor}}

2. Make a request to the ‘list-titles’ endpoint with that actor’s id to get their films as known by Watchmode:
   https://api.watchmode.com/v1/list-titles/?apiKey={{api_key}}&person_id={{actor_id}}

3. Make a request to the title’s ‘sources’ endpoint for each film listed to get the streaming services Watchmode think has it available:
   https://api.watchmode.com/v1/title/{{title_id}}/sources/?apiKey={{api_key}}=GB

You could run these manually - copying IDs from one response into the next - but where’s the fun in that? Let’s automate it.

Making It Dynamic with Postman Variables

If you’re new to Postman, the double braces ({{api_key}}, {{actor}}, etc.) represent variables. They let you store reusable values (like your API key or actor name) that Postman automatically substitutes into requests.

In this example:

• {{actor}} might be Jason Statham

• {{api_key}} is your Watchmode developer key

Automating the Workflow

One of Postman’s best features is that you can run custom JavaScript before and after each request using the Pre-request Script and Tests tabs. This lets you capture response data, save it as variables, and use it in later requests - all automatically.

Here’s what our flow now looks like:

1. Search endpoint

   • Make a request for the actor’s name

   • Extract the actor’s Watchmode ID

   • Save it as a collection variable: {{actor_id}}

2. List-titles endpoint

   • Use {{actor_id}} to fetch all films

   • Store each film’s ID and title as an array of objects in {{titles}}

3. Sources endpoint

   • Loop over each title in {{titles}}

   • Request the available streaming sources for each film

   • Save the results in a final variable: {{available_on}}

The Final Result

With just a handful of lines of JavaScript and Postman’s Collection Runner, you can pull every title for an actor and see exactly which of your streaming subscriptions carry it - all without leaving Postman. Here’s what Jason Statham films Watchmode API said was available for my chosen streaming services:

{
    "13":["Prime Video"],
    "Operation Fortune: Ruse de Guerre":["Prime Video"],
    "A Working Man":["Prime Video"],
    "Fast & Furious Presents: Hobbs & Shaw":["Netflix"],
    "The Expendables 2":["Netflix"],
    "Meg 2: The Trench":["Prime Video"],
    "Spy":["Disney+"],
    "The Mechanic":["Netflix"],
    "The Expendables 3":["Netflix"],
    "The Expendables":["Netflix"],
    "Collateral":["Netflix"],
    "Homefront":["Netflix","Prime Video"],
    "The Transporter":["Disney+"],
    "Transporter 2":["Disney+"],
    "Transporter 3":["Prime Video"],
    "Crank: High Voltage":["Prime Video"],
    "Hummingbird":["Disney+"],
    "Revolver":["Netflix","Prime Video"],
    "Cellular":["Netflix"],
    "Expend4bles":["Netflix"],
    "Safe":["Prime Video"],
    "Gnomeo & Juliet":["Prime Video"],
    "In the Name of the King: A Dungeon Siege Tale":["Prime Video"]
}

In the end I settled on 13, a gritty and suspensful film about a desperate young man unknowingly entering an underworld game of Russian roulette.

How It Works

Test script for our ‘search’ request to get the actor id:

// Parse JSON response
let jsonData = pm.response.json();

// Ensure people_results exists
if (jsonData.people_results && jsonData.people_results.length > 0) {
    let person = jsonData.people_results[0];
    let actorId = person.id;

    // Save actor ID
    pm.collectionVariables.set("actor_id", actorId);
    console.log(`✅ Saved actor_id ${actorId}`);
}

Test script for our ‘list-titles’ request to get the films:

let jsonData = pm.response.json();

if (jsonData.titles && jsonData.titles.length > 0) {
    // Save titles array
    let titlesArray = jsonData.titles.map(t => ({ id: t.id, title: t.title }));
    pm.collectionVariables.set("actor_titles", JSON.stringify(titlesArray));

    // Initialize index for looping - used in our final request to loop over each title
    pm.collectionVariables.set("current_index", 0);

    console.log("✅ Saved actor_titles and initialized current_index");
}

Pre-request script for our ‘sources’ request to handle the looping over titles:

let titles = JSON.parse(pm.collectionVariables.get("actor_titles") || "[]");
let index = parseInt(pm.collectionVariables.get("current_index") || "0");

let currentTitle = titles[index];

if (currentTitle) {
    pm.variables.set("title_id", currentTitle.id);
    pm.variables.set("title_name", currentTitle.title);
    console.log(`\n🎬 [Title ${index + 1}/${titles.length}] Processing: "${currentTitle.title}" (ID: ${currentTitle.id})`);
} else {
    console.warn("⚠️ No title found for this index");

    // Close the iterations
    postman.setNextRequest(null);
}

Test script for our ‘sources’ request to get the streaming sources offering each film:

// Parse JSON response for sources
let sources = pm.response.json();

// Retrieve existing results
let allResults = pm.collectionVariables.get("available_on");
allResults = allResults ? JSON.parse(allResults) : {};

// Get current title info
let titleId = pm.variables.get("title_id");
let titleName = pm.variables.get("title_name");

// Target streaming services - the services I have access to
// Can add 'Amazon' if you're open to renting
let targetSources = ["Netflix", "Prime Video", "Disney+"];

// Array to hold found services
let servicesFound = [];

let normalizedSources = sources.map(src => ({
    name: src.name ? src.name.trim().toLowerCase() : "",
    web_url: src.web_url
}));

targetSources.forEach(target => {
    let matched = normalizedSources.find(src => src.name.includes(target.toLowerCase()));
    if (matched) {
        servicesFound.push(target);
        console.log(`✅ Found ${target} for "${titleName}"`);
    } else {
        console.log(`❌ ${target} not found for "${titleName}"`);
    }
});

// Only set title if it's offered by our chosen services
if (servicesFound.length > 0) {
    allResults[titleName] = servicesFound;
}

// Save results
pm.collectionVariables.set("available_on", JSON.stringify(allResults));

// Increment index
let titles = JSON.parse(pm.collectionVariables.get("actor_titles") || "[]");
let index = parseInt(pm.collectionVariables.get("current_index") || "0") + 1;

// Loop or finish
if (index < titles.length) {
    pm.collectionVariables.set("current_index", index);
    console.log(`➡️ Moving to next title (${index + 1} of ${titles.length})`);
    postman.setNextRequest("Request 3"); // loop to same request
} else {
    console.log("✅ All titles processed!");
    postman.setNextRequest(null); // stop run
}

With everything configured, open Postman’s Collection Runner, select your collection, and set the request order to Search → Titles → Sources. Hit Run, and Postman will take care of the rest. When the run finishes, check your collection variables — you should see a new {{available_on}} variable containing your JSON blob of movie data.

In just a few clicks, you’ve built a custom, cross-platform movie search that finds films in seconds across all your streaming services.