Google Videos API: How to Scrape Video Search Results

Video search is no longer a side street in SEO.

For many queries, users do not only want a page to read. They want a demo, review, tutorial, webinar, walkthrough, comparison, product test, or event clip. That means video search results can shape how people discover brands, products, topics, and creators.

The problem is that checking Google Videos manually does not scale.

A Google Videos API helps you collect video search results as structured data. Instead of opening Google, switching to the Videos tab, copying links, and pasting them into a spreadsheet, your workflow can send a query and receive fields such as video title, URL, source, thumbnail, duration, date, snippet, and ranking position.

Talordata’s SERP API page lists Google Videos as one of the supported Google result types, and its SERP API supports structured search-result data with JSON / HTML response formats and geo-targeted SERP data.

Quick answer

To scrape Google video search results, use a SERP API request with the Google Videos engine, pass a search query, set localization parameters such as country, language, and location when needed, then parse the returned video results into a database, spreadsheet, dashboard, or AI workflow.

A simple workflow looks like this:

Keyword list
→ Google Videos API request
→ Parse video results
→ Extract title, URL, source, thumbnail, duration, date, position
→ Store snapshots
→ Compare visibility over time

Why scrape Google video search results?

Video results are useful because they show what Google surfaces for visual or tutorial-style search intent.

Teams use video search data to answer questions like:

This is useful for SEO teams, content teams, brand teams, product marketers, AI builders, and market research teams.

What data can you collect?

A practical Google Videos API workflow usually focuses on these fields:

Talordata’s own Google Videos article describes similar video search data points, including video titles, URLs, sources, thumbnails, publication dates, durations, ranking positions, snippets, channels, and key moments when available.

Google Videos API vs YouTube API

A Google Videos API and a YouTube API are not the same thing.

If you only care about your own YouTube channel, YouTube analytics may be enough.

If you care about what users see in Google video search across many sources, a Google Videos API is more useful.

For example, Google Videos may surface results from YouTube, news sites, social platforms, publishers, product pages, or other indexed video sources. A YouTube-only workflow would miss part of that search visibility picture.

Step 1: Prepare keywords

Start with a focused keyword set.

KEYWORDS = [
    "how to use project management software",
    "crm software demo",
    "best standing desk review",
    "python data visualization tutorial",
]

Good video-search keywords often include:

• how to

• tutorial

• demo

• review

• comparison

• setup

• unboxing

• webinar

• walkthrough

• product name

• brand name

Do not begin with thousands of keywords. Start small, inspect the returned data, then scale.

Step 2: Define search context

Video results can change by country, language, and location.

SEARCH_CONTEXTS = [
    {
        "country": "us",
        "language": "en",
        "location": "United States",
        "device": "desktop",
    },
    {
        "country": "gb",
        "language": "en",
        "location": "London, England, United Kingdom",
        "device": "desktop",
    },
]

This context matters for SEO and market research. A video ranking in the United States may not rank the same way in the United Kingdom, Japan, Brazil, or Germany.

The referenced Talordata parameter documentation shows Google Videos requests using engine=google_videos, q, and json=1; broader parameter references also list controls such as gl, hl, lr, location, uule, start, num, tbs, safe, nfpr, and filter for Google Videos-related requests.

Step 3: Send a Google Videos request

Use environment variables for the API key and endpoint.

import os
import requests


SERP_API_KEY = os.getenv("TALORDATA_API_KEY")
SERP_ENDPOINT = os.getenv("TALORDATA_SERP_ENDPOINT")


def call_google_videos_api(query, context):
    if not SERP_API_KEY:
        raise RuntimeError("Missing TALORDATA_API_KEY")

    if not SERP_ENDPOINT:
        raise RuntimeError("Missing TALORDATA_SERP_ENDPOINT")

    headers = {
        "Authorization": f"Bearer {SERP_API_KEY}",
        "Content-Type": "application/x-www-form-urlencoded",
    }

    data = {
        "engine": "google_videos",
        "q": query,
        "json": "1",
        "gl": context["country"],
        "hl": context["language"],
        "location": context["location"],
        "device": context["device"],
        "num": "20",
    }

    response = requests.post(
        SERP_ENDPOINT,
        headers=headers,
        data=data,
        timeout=30,
    )

    response.raise_for_status()
    return response.json()

Keep the request function small. It should only handle authentication, parameters, and HTTP errors.

Parsing should live in a separate function.

Step 4: Normalize video results

Different SERP layouts may return slightly different fields, so write a parser that is flexible.

def clean_text(value):
    if not value:
        return ""
    return " ".join(str(value).split())


def get_video_results(response_json):
    return (
        response_json.get("video_results")
        or response_json.get("videos_results")
        or response_json.get("videos")
        or response_json.get("results")
        or []
    )


def normalize_video_results(response_json):
    rows = []

    for index, item in enumerate(get_video_results(response_json), start=1):
        rows.append({
            "position": item.get("position") or item.get("rank") or index,
            "title": clean_text(item.get("title")),
            "url": item.get("link") or item.get("url") or "",
            "source": clean_text(item.get("source") or item.get("displayed_link")),
            "thumbnail": item.get("thumbnail") or "",
            "duration": clean_text(item.get("duration")),
            "date": clean_text(item.get("date")),
            "snippet": clean_text(item.get("snippet") or item.get("description")),
            "channel": clean_text(item.get("channel") or item.get("author")),
        })

    return rows

The goal is not to guess every possible field. The goal is to create a stable internal format that your team can use.

Step 5: Export results to CSV

For the first version, CSV is enough.

import csv
from datetime import datetime, timezone


CSV_COLUMNS = [
    "keyword",
    "country",
    "language",
    "location",
    "device",
    "position",
    "title",
    "url",
    "source",
    "thumbnail",
    "duration",
    "date",
    "snippet",
    "channel",
    "collected_at",
]


def export_video_results(rows, filename="google_video_results.csv"):
    with open(filename, mode="w", newline="", encoding="utf-8") as file:
        writer = csv.DictWriter(file, fieldnames=CSV_COLUMNS)
        writer.writeheader()
        writer.writerows(rows)

Then run the full workflow:

def run_video_search_collection():
    collected_at = datetime.now(timezone.utc).isoformat()
    output_rows = []

    for keyword in KEYWORDS:
        for context in SEARCH_CONTEXTS:
            response_json = call_google_videos_api(keyword, context)
            video_results = normalize_video_results(response_json)

            for video in video_results:
                output_rows.append({
                    "keyword": keyword,
                    "country": context["country"],
                    "language": context["language"],
                    "location": context["location"],
                    "device": context["device"],
                    "position": video["position"],
                    "title": video["title"],
                    "url": video["url"],
                    "source": video["source"],
                    "thumbnail": video["thumbnail"],
                    "duration": video["duration"],
                    "date": video["date"],
                    "snippet": video["snippet"],
                    "channel": video["channel"],
                    "collected_at": collected_at,
                })

    export_video_results(output_rows)


if __name__ == "__main__":
    run_video_search_collection()

Now you have a video search snapshot.

Run it daily or weekly, and you can track changes over time.

Step 6: Store snapshots for tracking

A single result set is only a snapshot. The real value comes from comparison.

A database table might look like this:

With historical data, you can answer:

• Which videos gained visibility?

• Which videos dropped?

• Which competitors appear repeatedly?

• Which platforms dominate the results?

• Which keywords trigger more video results?

• Which topics need new video content?

• Which video formats stay visible longest?

That turns video search into a measurable content and SEO signal.

Use cases

Video SEO monitoring

Track whether your videos appear for target keywords and whether ranking positions improve or decline over time.

Competitor video tracking

Monitor competitor videos, product reviews, webinars, tutorials, and comparison content that appear in Google Videos.

Content gap analysis

If important keywords show video results but your brand has no video presence, that may be a content opportunity.

Brand monitoring

Track brand, product, executive, event, or campaign queries to see what videos users may discover.

AI and RAG workflows

Structured video search data can help AI systems discover fresh multimedia sources, classify topics, and generate research summaries.

Talordata’s SERP API page lists AI search and agent integration, SEO rank monitoring, brand and competitor monitoring, local SEO, news monitoring, and e-commerce intelligence as related use cases for structured SERP data.

Test the Google Videos API for free >>

Best practices

Keep the keyword list focused. Video results are easier to analyze when queries are grouped by intent.

Always store search context. Keyword, country, language, location, device, and timestamp are essential for comparison.

Separate video results from organic web results. They answer different visibility questions.

Track source platforms. YouTube, publisher sites, short-video platforms, and news sites may behave differently.

Do not rely only on one snapshot. Video results can change quickly, especially around news, events, product launches, and trending topics.

Review thumbnails and titles manually for important keywords. Video search is visual, so metadata alone may miss presentation quality.

Use structured JSON for workflows and dashboards. Use HTML only when you need raw SERP inspection or custom debugging.

FAQ

What is a Google Videos API?

A Google Videos API collects Google video search results and returns structured data such as video titles, URLs, sources, thumbnails, durations, dates, snippets, and ranking positions.

Why scrape Google video search results?

Teams scrape Google video search results to monitor video SEO, competitor visibility, brand presence, content gaps, and multimedia search trends.

What fields should I collect from video search results?

Start with keyword, position, title, URL, source, thumbnail, duration, date, snippet, channel, location, language, device, and timestamp.

Is Google Videos API the same as YouTube API?

No. A YouTube API shows data from YouTube. A Google Videos API shows what appears in Google video search results, which may include YouTube and other video sources.

Can video search data support SEO?

Yes. It helps SEO and content teams understand which videos appear for target keywords, which competitors are visible, and which topics may need video content.

Can video search data support AI workflows?

Yes. AI systems can use structured video search data for source discovery, topic research, content classification, and RAG workflows.

How often should I collect Google video results?

Weekly tracking is often enough for evergreen topics. Daily tracking is useful for news, launches, brand monitoring, and fast-changing competitive topics.