# Google Short Videos Scraper – Shorts, Reels & TikTok Results (`simple.actor/google-short-videos`) Actor

Scrape Google’s Short videos tab as data: every short video Google lists for a search across YouTube Shorts, TikTok, Instagram Reels, Facebook, X, LinkedIn and Reddit — link, title, creator, duration, thumbnail, description and date. Filter by platform and time. No API key, no browser. Unofficial.

- **URL**: https://apify.com/simple.actor/google-short-videos.md
- **Developed by:** [Simple Actor](https://apify.com/simple.actor) (community)
- **Categories:** Videos, Social media, SEO tools
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 video returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Short Videos Scraper – Shorts, Reels & TikTok Results

Scrape Google's **Short videos** tab as structured data. Type what you would
type into Google, and every short video Google lists for it comes back as a
row — from **YouTube Shorts, TikTok, Instagram Reels, Facebook, X, LinkedIn
and Reddit** in one result set — with the video's **link on its own
platform**, its title, creator, platform, duration, Google's thumbnail, the
description Google carries for it and the publish date where Google shows
one. In Google's own order.

Built for trend and content research, creator and competitor monitoring,
social listening, short-form SEO, and building datasets of what the world is
watching on a topic. Every filter from the tab's **Tools** menu is here:
platform, time, high quality and closed captions.

**No API key, no login, no browser, no account of yours involved.** Twelve
videos arrive per request; a search usually finishes within a minute, and
reads of many pages run several at a time.

**$0.80 per 1,000 videos, plus $0.006 for each search Google answers** —
about $0.016 for a typical 12-video search. Apify platform usage included,
nothing else to pay. A search that cannot be read is never charged.

*Unofficial. Not affiliated with, endorsed by, or sponsored by Google or any
of the platforms whose videos it lists.*

### Features

- **Every platform in one search** — Google ranks YouTube Shorts, TikTok,
  Instagram Reels, Facebook, X, LinkedIn and Reddit videos together, and so
  do the rows. `videoUrl` is the video's address on its own platform, and
  `videoId` its ID there.
- **Who made it, how long it is** — `creator`, `platform`, `duration` and
  `durationSeconds` on every row.
- **Google's thumbnail, no extra fetch** — `thumbnailUrl` is Google's own
  frame of the video, inline as a `data:` URL that displays in any `<img>`
  tag. About a quarter of videos also carry `previewUrl`, a short silent MP4
  preview Google made.
- **A description and a date** — `description` is what Google carries for
  the video; `publishedAt` is the publish date Google shows, as an ISO date,
  with the text Google wrote in `dateText`. Google shows dates for YouTube
  videos and few others.
- **Every Tools-menu filter** — one platform at a time, time (past hour to
  past year), high quality, closed captions, and SafeSearch.
- **As deep as Google goes** — twelve videos a request, paged until you have
  what you asked for or Google runs out, which is somewhere around 350–450
  videos for most searches.
- **Many searches in one run** — one per line, each with its own rows.
- **Paste a Google link** — a link copied from your browser's Short videos
  tab is read with its own search terms and filters.
- **Country and language** — search as Google does from another country.
- **Runs stay green.** A search that cannot be read becomes an error row, so
  one bad line never costs the rest of the job.

### Input

```json
{
  "queries": ["easy pasta recipe"],   // one search per line
  "maxItems": 12,                      // videos per search (12 = one request)
  "platform": "any",                   // any | youtube | tiktok | instagram | facebook | x | linkedin | reddit
  "timeRange": "any",                  // any | hour | day | week | month | year
  "highQuality": false,
  "closedCaptions": false,
  "safeSearch": false,
  "country": "US",
  "language": "en"
}
```

Google's operators work in the search terms:

```json
{
  "queries": [
    "\"air fryer\" recipe",
    "iphone tips -android",
    "https://www.google.com/search?q=golden+retriever+puppies&udm=39"
  ]
}
```

| Field | Type | Default | What it does |
|---|---|---|---|
| `queries` | array | — | Search terms, one per line, or links copied from Google's Short videos tab. |
| `maxItems` | integer | `12` | Videos per search, up to 400. Twelve arrive per request; Google runs out at roughly 350–450. |
| `platform` | string | `any` | Only one platform: `youtube`, `tiktok`, `instagram`, `facebook`, `x`, `linkedin` or `reddit`. |
| `timeRange` | string | `any` | `hour`, `day`, `week`, `month` or `year`. |
| `highQuality` | boolean | `false` | Google's "High quality" filter. |
| `closedCaptions` | boolean | `false` | Google's "Closed captioned" filter. |
| `safeSearch` | boolean | `false` | Have Google filter explicit videos out. |
| `country` | string | `US` | Two-letter code: `US`, `GB`, `DE`, `IN`… |
| `language` | string | `en` | `en`, `de`, `fr`, `es`, `pt-BR`, `ja`… |

A pasted Google link keeps its own filters; the filter fields apply to links
that carry none, and to every plain search.

#### How many videos

Google lists twelve videos per request, so the default of 12 is a single
request. Ask for more and further requests are made until you have them or
Google runs out — for most searches that is somewhere around 350 to 450
videos, the same point where the Short videos tab stops scrolling in a
browser. Reading stops there on its own.

### Output

One item per video, in the run's dataset:

```json
{
  "type": "video",
  "position": 1,
  "title": "Google's AI Is Getting Ridiculous…",
  "videoUrl": "https://www.youtube.com/shorts/VvUAgcp0v2M",
  "platform": "YouTube",
  "domain": "youtube.com",
  "creator": "Andres Vidoza",
  "duration": "1:15",
  "durationSeconds": 75,
  "description": "I gave Gemini the busy work. It gave me my time back. Buy back your time with Google AI Pro and your 24/7 personal AI agent within Gemini.",
  "publishedAt": "2026-09-17",
  "dateText": "Sep 17, 2026",
  "thumbnailUrl": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wCEAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD84QzQ5OjcBCgoKDQwNGg8PGjclHyU3Nzc3Nzc3…",
  "previewUrl": null,
  "videoId": "VvUAgcp0v2M",
  "query": "google",
  "searchUrl": "https://www.google.com/search?q=google&udm=39&hl=en&gl=US",
  "page": 1,
  "retrievedAt": "2026-09-24T07:12:31.000Z"
}
```

| Field | What it is |
|---|---|
| `videoUrl`, `videoId` | The video's link on its own platform, and its ID there — a YouTube video ID, TikTok video number, Instagram reel code… |
| `platform`, `domain` | The platform's name as Google shows it, and the link's host. |
| `creator` | The channel, account or page that posted the video. |
| `duration`, `durationSeconds` | The video's length as Google shows it, and in seconds. |
| `title`, `description` | The title Google shows, and the description Google carries — the video's own, or its platform page's summary, shortened. |
| `publishedAt`, `dateText` | The publish date as an ISO date and as Google wrote it, when Google shows one. |
| `thumbnailUrl` | Google's thumbnail, inline as a `data:` URL (a JPEG of about 10KB). |
| `previewUrl` | A short silent MP4 preview Google made, on about a quarter of videos. |
| `position`, `page` | Google's rank, 1 first, and which request of the search it came from. |
| `query`, `searchUrl` | The search, and the Google address it was read from. |

A search that could not be read is its own row with `type: "error"`, an
`error` code and an `errorDescription`. The run itself stays green either way,
and its status message says how many searches could not be read — so if you
run on a schedule, check for `type: "error"` rows rather than trusting the run
status.

An empty dataset means the searches were read and Google lists no short
videos for them. It never means a search could not be made; that arrives as
an error row instead.

### How to use

#### From Apify Console

1. Open the Actor and click **Try for free** / **Start**.
2. Put one search per line into **Search terms** — or paste a link from your
   browser's Google Short videos tab.
3. Set **Videos per search**. 12 is one request; Google has roughly 350–450
   for most searches.
4. Pick a **Platform** or **Time** filter if you want one, exactly as in the
   tab's Tools menu.
5. Click **Start**, then open the **Dataset** tab — the Videos view shows a
   thumbnail of each — and export as JSON, CSV or Excel.

#### From the API

```bash
curl -s "https://api.apify.com/v2/acts/simple.actor~google-short-videos/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries": ["easy pasta recipe"], "platform": "tiktok", "maxItems": 24}'
```

With the JavaScript client:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('simple.actor/google-short-videos').call({
    queries: ['easy pasta recipe', 'air fryer recipe'],
    timeRange: 'month',
    maxItems: 36,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
// items[].videoUrl is the video on its platform; items[].creator is who posted it.
```

### Use cases

- **Trend and content research** — what short-form video exists on a topic
  right now, across every platform at once, with `timeRange` for what is new.
- **Creator and competitor monitoring** — which creators Google surfaces for
  your keywords, and how often, on a schedule.
- **Short-form SEO** — see which videos rank in Google's Short videos tab for
  your terms, and where yours sit.
- **Social listening** — brand, product or event mentions in short video,
  with the description and the creator on every row.
- **Datasets** — hundreds of videos per term with a stable `videoId` to
  deduplicate, a thumbnail to display, and `durationSeconds` to filter on.
- **Local research** — how a topic looks in another country's results, with
  `country` and `language`.

### Pricing

Simple pay-per-result pricing — no subscription.

| Event | Price |
|---|---|
| Video returned | $0.0008 |
| Search answered, once per search | $0.006 |
| Run start (Apify's standard start event) | $0.00005 |

What that comes to:

- A search at the default depth, 12 videos: **about $0.016**.
- A narrow search that finds three videos: **about $0.0084**.
- A hundred videos from one search: **about $0.086**.
- 1,000 videos: **$0.80**, plus $0.006 for each search they came from.

Error rows are never charged: a search that could not be read costs nothing.
A search Google answers is charged once whether it lists videos or none,
because Google is asked either way and "no short videos" is a real answer.

### Limits worth knowing

- **Google stops at roughly 350–450 videos a search.** That is where the
  tab stops scrolling in a browser too; asking for more returns what Google
  has.
- **One platform at a time.** Google's Source filter takes one platform;
  asked for two, it ignores the filter. Run one search per platform instead.
- **Dates are Google's.** Google shows a publish date for YouTube videos and
  few others; where it shows none, `publishedAt` and `dateText` are `null`.
  Dates are parsed into `publishedAt` for English and numeric forms; in other
  languages `dateText` still carries the text.
- **No view counts.** Google's Short videos tab does not show them, so the
  rows cannot either.
- **A very specific or misspelled search is not flagged.** Google loosens a
  search it has little for and shows related videos without saying so.

### FAQ

**Is scraping Google's short video results legal?**
Results come from Google and are subject to Google's terms, and the videos
belong to their creators and platforms. This Actor returns links and
descriptions, not copies of the videos. Searches go through Apify's Google
SERP proxy, which is the sanctioned route to Google's results pages.

**Do I need a Google API key or a search API account?**
No. There is no key, no login, no browser and no quota of your own to manage.

**Does it download the videos?**
No. Each row carries the video's link on its platform and Google's
thumbnail; fetch the video with a downloader for that platform if you need
the file.

**Why is the thumbnail a `data:` URL?**
Because that is how Google's page carries it — embedded, not served from an
address — so it works without another request and never goes stale. It
displays in any `<img>` tag and in Apify's dataset view.

**How do I know a search failed if the run stays green?**
Check for rows with `type: "error"` — that is the failure channel by design, so
one bad search never costs the rest of the job. The run's status message also
counts how many searches could not be read.

Results come from Google and are subject to Google's terms. Searches use
Apify's Google SERP proxy. Unofficial, and not affiliated with Google or with
any platform whose videos appear in the results.

# Actor input Schema

## `queries` (type: `array`):

What to search for, one search per line. Google's operators work: "exact phrase" in quotes, a minus sign to exclude a word. You can also paste a link copied from Google's Short videos tab — its search terms and filters are used as they are, and the filters below apply only to links that carry none.

## `maxItems` (type: `integer`):

How many videos to return per search. Google lists twelve per request, so the default of 12 is one request and 120 is about ten. Google's Short videos tab runs out somewhere around 350–450 videos for most searches, and reading stops there on its own — asking for more returns everything Google has.

## `platform` (type: `string`):

Only videos from one platform, as Google's Tools menu offers under Source. Leave on "All platforms" for the mix Google shows. One platform at a time — Google ignores the filter when asked for two.

## `timeRange` (type: `string`):

Only videos Google found within this period — the way to get what is new on a topic.

## `highQuality` (type: `boolean`):

Google's "High quality" filter from the Tools menu. In testing it narrowed results to YouTube.

## `closedCaptions` (type: `boolean`):

Google's "Closed captioned" filter from the Tools menu — videos Google knows to carry captions.

## `safeSearch` (type: `boolean`):

Turn on to have Google filter explicit videos out, as its SafeSearch setting does.

## `country` (type: `string`):

The country Google searches from, as a two-letter code: US, GB, DE, IN… Videos from local creators rank higher. Defaults to US.

## `language` (type: `string`):

The language of Google's interface and of the videos it prefers: en, de, fr, es, pt-BR, ja… Defaults to en. Set it together with the country for a local search. Dates come back as Google writes them in this language, and are parsed into publishedAt for English and numeric forms.

## Actor input object example

```json
{
  "queries": [
    "easy pasta recipe",
    "iphone tips"
  ],
  "maxItems": 12,
  "platform": "any",
  "timeRange": "any",
  "highQuality": false,
  "closedCaptions": false,
  "safeSearch": false,
  "country": "DE",
  "language": "de"
}
```

# Actor output Schema

## `videos` (type: `string`):

One row per video: thumbnail, title, platform, creator, duration, date and the search it answered.

## `links` (type: `string`):

Each video's link on its own platform, with its ID, for opening or crawling.

## `raw` (type: `string`):

Every field of every item, exactly as pushed.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "easy pasta recipe"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("simple.actor/google-short-videos").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": ["easy pasta recipe"] }

# Run the Actor and wait for it to finish
run = client.actor("simple.actor/google-short-videos").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "easy pasta recipe"
  ]
}' |
apify call simple.actor/google-short-videos --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,simple.actor/google-short-videos"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/CyfcQqgfQv4RKY7yW/builds/XjNJlAMgNE169Tdab/openapi.json