# Google Shorts Scraper - Short Videos Google Ranks for a Keyword (`s-r/google-shorts-scraper`) Actor

The short videos Google surfaces for a search term, from its own short-videos tab: video id, title, channel, duration and both desktop and mobile links. A ranking view rather than a channel catalogue.

- **URL**: https://apify.com/s-r/google-shorts-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Shorts Scraper

The short videos Google surfaces for a search term, from its own short-videos
tab. One row per short with the video id, the title, the channel, the duration
and both the desktop and mobile links.

### This is a ranking view, not a catalogue

The distinction matters before you build anything on it. A YouTube scraper
answers "what has this channel published". This answers "**what does Google
show when somebody searches this**", which is a different question and usually
the more useful one for marketing.

It is also a different surface from Google's ordinary video tab. On the same
query, the short-videos tab returned eighteen shorts and the video tab returned
thirty ordinary videos and no shorts at all.

### Regional

Short videos are heavily regional: the same keyword surfaces different creators
in the US than in the Netherlands. **Country** and **Language** are separate
inputs and both are carried on every row, so a multi-market run stays sortable.

### Two links per video

`url` is the desktop link and `mobile_url` is the one Google's own card points
at. They are the same video and they behave differently: the mobile form opens
the app on a phone, the desktop one opens the web player. Both are on the row
so you can use whichever suits where the link is going.

### Titles get cut

Google truncates long titles on the results page with an ellipsis. The ellipsis
is stripped and `title_truncated` is set instead, so you can tell a short title
from a cut one. The full title lives on the video itself.

### Errors

| Code | Meaning |
|---|---|
| `blocked` | No attempt got a results page back |
| `no_results` | A page was served with no shorts on it |
| `bad_input` | No keyword was given |

Roughly one attempt in five is served, so retries are normal and the default
clears it comfortably. Raise **Attempts per keyword** if you see `blocked`.

`no_results` is a real answer: not every search has short videos behind it.

### Related actors

`youtube-shorts-scraper` for a channel's own shorts, `youtube-scraper` for
ordinary YouTube search, and the Google SERP actors for the blue links beside
these.

# Actor input Schema

## `keywords` (type: `array`):

One per line. These are Google searches, so write them the way someone would type them.

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

Two-letter interface language.

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

Two-letter market code. Short videos are regional, so the same keyword returns different creators per market.

## `maxVideos` (type: `integer`):

Stop after this many rows. Also the cost ceiling for the run.

## `attempts` (type: `integer`):

How often to retry with a fresh session and exit. Roughly one draw in five is served, so a handful of retries is normal.

## Actor input object example

```json
{
  "keywords": [
    "air fryer recipes"
  ],
  "language": "nl",
  "country": "nl",
  "maxVideos": 100,
  "attempts": 10
}
```

# Actor output Schema

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

One row per short.

## `summary` (type: `string`):

Videos returned, distinct channels, and how many titles Google truncated.

## `errors` (type: `string`):

Keywords that could not be read.

# 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 = {
    "keywords": [
        "price scraper"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/google-shorts-scraper").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 = { "keywords": ["price scraper"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/google-shorts-scraper").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 '{
  "keywords": [
    "price scraper"
  ]
}' |
apify call s-r/google-shorts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/google-shorts-scraper"
        }
    }
}
```

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/K2c5OdqQd8aNFdaN1/builds/A96bkgdcpl9JACbFj/openapi.json