# Short Video Search API (`truefetch/short-video-search-api`) Actor

Short Video Search API turns one keyword into canonical public video links from two independent short-video search indexes, returning deduplicated 12-field JSON rows with title, thumbnail, source, creator, duration, view text and recency text.

- **URL**: https://apify.com/truefetch/short-video-search-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Videos, Social media, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.63 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

**Short Video Search API is a short video search API that resolves one keyword into canonical public video links across two independent short-video indexes and returns them as deduplicated 12-field JSON rows, built for developers and data teams.**

- **One call, two indexes:** both short-video surfaces are queried in the same run and merged on canonical URL before any row is returned.
- **Fixed 12-key row shape:** every item carries the same keys — including which engine found it and its rank there — with `null` where a result card did not display a value.
- **Public destination URLs:** each row resolves to the video's own public page rather than a search-result redirect.
- **Row-based billing:** a Result event is charged only for an item actually written to the default Dataset.

[**Run a one-result test**](https://apify.com/truefetch/short-video-search-api) · [**View API**](https://apify.com/truefetch/short-video-search-api/api)

A first call with `max_results: 1` costs at most $0.025 on the FREE tier — $0.01 for the run start plus $0.0075 for each of up to two returned rows, one per index — so the API can be verified end to end for under three cents.

### What does Short Video Search API do?

It converts a keyword into a list of public short-video destinations with their card metadata: distinct canonical video URLs annotated with title, source platform, creator, duration, thumbnail, and the view and recency text the originating result card displayed.

Two independent short-video indexes are queried in the same run, or one of them when the call selects it. Each selected index is walked page by page until it fills its own `max_results` budget or runs out of new destinations. Results merge on canonical URL, so a video both indexes return is one billed row, not two.

It is a discovery layer: every row is a public destination link with the metadata its result card displayed, drawn from what the two indexes currently rank for the keyword. Media files, transcripts and live engagement counters are the next step, and the platform-specific Actors under Related take a returned `url` for exactly that.

### How do I run Short Video Search API?

Send a keyword and a result budget, optionally pick one index, wait for the run to finish, and read the Dataset.

1. Set `keyword` to one topic, phrase, creator name, or public video identifier, 1 to 200 characters.
2. Set `max_results` to the number of unique video links the call should return **from each selected index**. The minimum is 1 and there is no ceiling.
3. Optionally set `platforms` to `["google"]` or `["bing"]` to query one index; omitting it or sending `[]` queries both.
4. Start the run through the Console, the API, or MCP. Each selected index gets the full `max_results` budget, so a two-index call returns up to twice it.
5. Read the default Dataset when the run reaches `SUCCEEDED`.

```json
{
  "keyword": "morning routine",
  "max_results": 40
}
```

The result limit applies per index and is counted in saved Dataset rows, which is also the billing unit — a `max_results: 40` call can return up to 80 links and bills one Result event per link actually returned, regardless of how many pages produced them.

### What data does Short Video Search API return?

Each row is one distinct public video destination described by 12 fields.

| Field | Type | Description |
| --- | --- | --- |
| `search_engine` | string or null | Which search engine returned the card: `Bing` or `Google` |
| `search_index` | integer or null | The card's rank in the sequence its engine returned, starting at 1 per engine; numbers can skip where the other engine returned the same video first |
| `source` | string or null | Video website or publisher platform the card credits |
| `title` | string or null | Video title displayed on the result card |
| `url` | string or null | Canonical public video page URL |
| `thumbnail_url` | string or null | Thumbnail image URL supplied with the card |
| `duration` | string or null | Displayed duration text |
| `channel_name` | string or null | Displayed creator, channel, or publisher name |
| `views_text` | string or null | Rounded view-count text when the card carries one |
| `published_text` | string or null | Relative publication text when the card carries one |
| `processor` | string or null | Store URL of the Actor that produced the row |
| `processed_at` | string or null | UTC timestamp for when the row was produced |

The item below is one real row from a `morning routine` call; every other row has exactly this shape.

```json
{
  "search_engine": "Bing",
  "search_index": 1,
  "source": "TikTok",
  "title": "Morning routine for happiness and joy",
  "url": "https://www.tiktok.com/@baileybeefsteak/video/7680206581262241054",
  "thumbnail_url": "https://th.bing.com/th/id/OVF.vY7Yl59CYk1bP9QPwejtmw?w=262&h=354&c=8&rs=1",
  "duration": "1:25",
  "channel_name": "baileybeefsteak",
  "views_text": "115.6K views",
  "published_text": "4 days ago",
  "processor": "https://apify.com/truefetch/short-video-search-api",
  "processed_at": "2026-09-05T03:49:31+00:00"
}
```

Values a result card does not display remain `null`. Nothing is estimated, back-filled, or inferred from another field. The `processor` value carries a publisher referral parameter in real output, which is left off the sample above.

### What inputs can I configure?

Three inputs in schema order: two required, one optional.

| Input | Type | Required | Notes |
| --- | --- | --- | --- |
| `keyword` | string | Yes | One topic, phrase, creator name, or public video identifier. 1 to 200 characters; surrounding whitespace is trimmed and empty or multi-line values are rejected. |
| `platforms` | array of strings | No | Which search indexes to query: `google`, `bing`, or both. Omitted or empty queries both. |
| `max_results` | integer | Yes | Maximum unique video links to return from *each* selected index, so a two-index call returns up to twice this. Minimum 1, no maximum. A link found in both is returned once. |

The optional `platforms` array is the API's one selector, and it chooses the search index rather than the destination site. The surface is deliberately three fields wide so that a call can be constructed from a keyword list without a configuration layer.

### What platforms and markets does Short Video Search API cover?

Coverage is defined by what the two indexes rank, not by a fixed platform list. Rows resolve to public destinations on YouTube, TikTok, Instagram, Facebook, Vimeo, and Dailymotion, and the mix shifts with the keyword — a recipe phrase skews toward Shorts and TikTok, a product phrase toward Reels and Facebook.

The short vertical format the API discovers is defined by the destination platforms themselves; [YouTube's official Shorts help page](https://support.google.com/youtube/answer/10059070) documents what qualifies there. Queries are issued against US-facing index results, so ranking reflects that market; keywords in any language are accepted and non-Latin scripts return results normally.

The platform mix for a given search is whatever the two indexes currently rank for that keyword, so a platform's share rises and falls with the topic.

### Why use Short Video Search API?

Because cross-platform short-video discovery is otherwise a per-platform integration problem, and this collapses it into one keyword-in, rows-out call.

| Capability | What it gives a developer |
| --- | --- |
| Two indexes merged on canonical URL | Wider destination coverage than a single-index query, with no client-side deduplication step |
| Fixed 12-key row shape | Rows load into a table or a warehouse without a normalization layer, run after run |
| Per-index selection | `platforms` narrows a call to one index when a workflow wants that index's ranking alone |
| Result-event billing | Spend is a linear function of rows delivered, so a per-keyword budget is calculable before the call |
| No credentials required | No platform accounts, tokens, or session cookies to provision, rotate, or expire |
| `processed_at` on every row | Run-to-run diffs stay interpretable without a separate ingestion timestamp |

Each row carries what the result card displayed — title, source, creator, duration, thumbnail, and the card's view and recency text — so this is the discovery stage of a pipeline whose engagement-analytics stage belongs to a platform-specific tool.

### Who is Short Video Search API for?

Developers and data teams building content-discovery pipelines, trend dashboards, creator-sourcing tools, or brand-monitoring workflows that need short-video coverage across platforms rather than inside one.

- A growth team feeding a weekly keyword list in and diffing `url` sets between runs.
- An agency building a creator shortlist from `channel_name` and `source` before outreach.
- A media desk collecting links and thumbnails into an editorial review queue.
- An agent workflow that discovers candidates here and passes each `url` to a transcript step.

It fits the workflows above because they start from a keyword and need public coverage across platforms; a workflow whose next step is engagement analytics, media files, or a platform-native filter such as a hashtag pairs this call with the platform-specific Actor that carries those.

### How can I use Short Video Search API through the API or MCP?

Call it as `truefetch/short-video-search-api`, start the run asynchronously, then read the Dataset the run created.

```bash
## 1. start the run
curl -X POST "https://api.apify.com/v2/acts/truefetch~short-video-search-api/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"morning routine","max_results":40}'

## 2. poll until "status" is "SUCCEEDED", or register an ACTOR.RUN.SUCCEEDED webhook
curl "https://api.apify.com/v2/actor-runs/RUN_ID?token=$APIFY_TOKEN"

## 3. read the rows
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=$APIFY_TOKEN"
```

`RUN_ID` is the `data.id` returned by step 1 and `DATASET_ID` is its `data.defaultDatasetId`; both are available the moment the start call returns. A `run-sync*` endpoint is a quick-test shortcut only: Apify closes a synchronous connection after 300 seconds **without aborting the run**, a client-side timeout never stops a run that is already billing, and each retry starts another billed run.

For MCP, expose the Actor through Apify's MCP integration, select `truefetch/short-video-search-api`, and pass `keyword` and `max_results` — plus `platforms` when one index is wanted — as tool arguments, the same object the HTTP body carries. Generated SDK snippets and the OpenAPI definition are on the [API page](https://apify.com/truefetch/short-video-search-api/api).

### How much does Short Video Search API cost?

Each returned row costs $0.0075 on the FREE tier and each call adds one $0.01 run start, so the smallest verifiable test — one returned link — totals $0.0175.

| Event or tier | Price | Billing unit |
| --- | ---: | --- |
| Actor Start | $0.01 | Once per run; Apify counts one start event per allocated GB, minimum one |
| Result — FREE | $0.00750 | Per row returned in the default Dataset |
| Result — BRONZE | $0.00675 | Per row returned in the default Dataset |
| Result — SILVER | $0.00600 | Per row returned in the default Dataset |
| Result — GOLD | $0.00563 | Per row returned in the default Dataset |
| Result — PLATINUM | $0.00563 | Per row returned in the default Dataset |
| Result — DIAMOND | $0.00563 | Per row returned in the default Dataset |

The Actor runs at 512 MB, so the start event is charged once per call — Apify counts one start event per GB with a minimum of one. Billing follows delivered rows, never attempted requests, so a keyword returning 12 links against `max_results: 40` bills 12 Results, and a single-index call (`platforms: ["bing"]` or `["google"]`) bills at most `max_results` rows plus the start. Batching a larger `max_results` into one call is therefore cheaper than splitting the same links across several. See [current pricing](https://apify.com/truefetch/short-video-search-api/pricing); prices can change.

### How does Short Video Search API compare with alternatives?

Against a manual search it wins as soon as the query repeats: a browser answers faster once, but offers no pagination, no export, no canonical deduplication, and nothing to diff next week.

Against per-platform integrations it trades depth for reach. Each platform's own official API returns richer records for its own content and is the better choice once the workflow knows which platform matters. This API answers the earlier question: which public short videos exist on this topic anywhere, in one list, with one billing unit.

Against a general web-search tool, the difference is what reaches the Dataset — a general tool returns articles, listings, and ads alongside videos, while this returns only short-video result cards.

### What are the limits and troubleshooting steps?

- **Zero rows returned.** The keyword may have no ranked short-video results, or one index may be briefly unavailable. Re-run with a broader public phrase; the smallest reproducible input is `{"keyword":"morning routine","max_results":1}`.
- **Fewer rows than `max_results` from one index.** Delivered volume is bounded by what each index ranks for that keyword; a narrow phrase can leave either index short. `max_results` is a per-index budget, not a guarantee.
- **A full call takes a few minutes.** A `max_results: 100` call walks both indexes to their budgets and typically completes in two to four minutes; poll the run or use the `ACTOR.RUN.SUCCEEDED` webhook rather than a synchronous call.
- **Counts differ between identical calls.** Index contents and ranking change continuously. Use `url` as the stable key and retain `processed_at`.
- **`views_text` or `published_text` is null.** These are card display strings, not computed metrics, and `Bing` rows supply them far more often than `Google` ones. Treat `null` as absence, never as zero.
- **`thumbnail_url` is null on some rows.** `Bing` rows ship thumbnails and `Google` rows usually omit them; filter on `search_engine` when the image is required. `url` is always present.
- **Two rows look like the same video.** A repost and an original upload are different public URLs and stay distinct rows by design.
- **A returned URL no longer opens.** Index entries outlive removed, private, or renamed pages. Validate links before publishing them downstream.

For a reproducible defect, open an [Actor Issue](https://apify.com/truefetch/short-video-search-api/issues) with the run ID, the exact input object, the expected behavior, and one affected `url`.

### Frequently asked questions

#### Is there a free short video search API?

The Actor is pay-per-event at $0.01 per run start plus $0.0075 per returned row on FREE, and those events are billed against the platform credits included with an Apify plan, so a small evaluation typically consumes plan credits rather than a separate invoice.

#### How do I run a bulk short video keyword search?

Issue one run per keyword with the `max_results` budget you want for that phrase, and parallelize at the API layer rather than inside a single call — the input takes exactly one `keyword`. Each run pays its own $0.01 start event, so a larger `max_results` per keyword is cheaper than splitting one keyword across several runs.

#### Can I schedule runs to monitor short-video results over time?

Yes. Point an Apify Schedule at a fixed input, then compare `url` sets and `processed_at` across the produced Datasets, or route each `ACTOR.RUN.SUCCEEDED` webhook into your own store and diff there.

#### Why do rows from one index carry more metadata than rows from the other?

The `search_engine` value names which engine produced the row, and the two describe their cards differently. `Bing` rows consistently supply thumbnails, view text, and relative dates; `Google` rows supply titles, durations, creators, and links but usually omit display metrics. The row shape stays identical across both — the difference appears as `null` values, never as missing keys — and `search_index` is each engine's own rank, so sorting on `search_engine` then `search_index` restores either engine's order.

#### How is a video that both indexes return billed?

Once. Canonical URLs are compared across both indexes before anything is written, so a video ranked by both produces exactly one Dataset row and exactly one Result event, under the engine that reached it first.

#### Which credentials does the API need?

Only your Apify API token. The API takes a keyword and a limit; the two search surfaces it reads are public, so platform tokens, cookies and logins play no part in a call.

#### What happens if one index fails mid-run?

The other continues and the run still returns rows. Whatever the failing index already delivered is kept. A call in which a selected index failed and nothing at all was returned finishes with a failed run status, so a scheduler or webhook can retry it, while a keyword with genuinely no matches finishes successfully with an empty Dataset.

#### Can I query a single search index?

Yes. Set `platforms` to `["google"]` or `["bing"]` and that index receives the whole `max_results` budget, so the call returns up to `max_results` rows from it; omit `platforms` or send `[]` to query both. For one destination site only, such as TikTok links, filter the returned rows on `source`, and use a platform-specific Actor when the workflow needs that platform's native filters and engagement data.

### Related TrueFetch Actors

- [Multi Engine Search API](https://apify.com/truefetch/multi-engine-search-api) — choose this when the same keyword also needs ordinary web results, not short-video cards alone.
- [Best Video Downloader](https://apify.com/truefetch/best-video-downloader) — choose this to turn a returned `url` into a downloaded media file where that is lawful for your use.
- [Video To Text](https://apify.com/truefetch/video-to-text) — choose this to convert a discovered public video into searchable transcript text.

### Support

Product questions, coverage questions, and integration help go to the [TrueFetch community on Telegram](https://t.me/TrueFetch); reproducible defects belong in an [Actor Issue](https://apify.com/truefetch/short-video-search-api/issues) with the run ID and the exact input. The [Store page](https://apify.com/truefetch/short-video-search-api) carries live pricing and the [API page](https://apify.com/truefetch/short-video-search-api/api) carries generated SDK snippets.

[**Run a one-result test**](https://apify.com/truefetch/short-video-search-api) · [**View API**](https://apify.com/truefetch/short-video-search-api/api)

**Last Updated:** September 5, 2026

# Actor input Schema

## `keyword` (type: `string`):

One topic, phrase, creator name, or public video identifier to search.

## `platforms` (type: `array`):

Search platforms to query: google, bing, or both. Omit or leave empty to query both. Max Results applies to each selected platform.

## `max_results` (type: `integer`):

How many unique short-video links one call returns from each selected platform, so a call can return up to twice this number when both are queried. Minimum 1 and no maximum; a platform stops early when it runs out of links the call has not already returned. A link both platforms return is returned once.

## Actor input object example

```json
{
  "keyword": "morning routine",
  "max_results": 2
}
```

# Actor output Schema

## `results` (type: `string`):

Links to the Dataset overview containing the normalized short-video search cards returned by this run.

# 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 = {
    "keyword": "morning routine",
    "max_results": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/short-video-search-api").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 = {
    "keyword": "morning routine",
    "max_results": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/short-video-search-api").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 '{
  "keyword": "morning routine",
  "max_results": 2
}' |
apify call truefetch/short-video-search-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/short-video-search-api"
        }
    }
}

```

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/Uqw2rcys0pH9aQHNr/builds/8aWq4QveyeIslsBac/openapi.json