# Multi Engine Search API (`truefetch/multi-engine-search-api`) Actor

Multi engine search api that queries 10 web search platforms in one call, Google, Bing, Baidu, Yandex, Naver and more. One row per platform result: title, snippet, url, source, ad flag, the platform and its rank, plus the page as Markdown.

- **URL**: https://apify.com/truefetch/multi-engine-search-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** SEO tools, Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.88 / 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?

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

## Multi Engine Search API

**Multi Engine Search API is a multi engine search api that sends one search phrase to ten web search platforms in one call and returns every platform's own ranked results as rows in one Dataset, built for developers and data teams.** It is a search across several platforms, not a batch of queries against one index: each row names the platform that returned it and the rank it held there, and the result page travels with the row as Markdown.

- **Ten platforms in one call** — Google, Bing, Baidu, Yandex, Naver, Sogou's WeChat search, Seznam, So.com, DuckDuckGo and Brave share one input and one 13-field output.
- **Every platform's own ranking, kept** — a page three platforms returned is three rows, each with that platform's real `position`; paid placements are flagged with `is_ad` and never take an organic rank.
- **Per-platform result budgets** — `max_results` applies to each platform you select, so ten platforms at 20 can return up to 200 rows.
- **Page text on every readable row** — each result page is read once, `content_status` records whether it could be read, and readable pages arrive as Markdown with a word count.

[**Run a two-result test**](https://apify.com/truefetch/multi-engine-search-api) · [**View API**](https://apify.com/truefetch/multi-engine-search-api/api)

At the configured 1 GB memory, a two-row test from one platform costs $0.01 Actor Start plus 2 × $0.00250, or $0.01500 on the FREE tier.

### What does Multi Engine Search API do?

It sends one search phrase to up to ten web search platforms at the same time and returns every platform's results as rows in one Dataset. Each platform is paged until it has the rows you asked for or stops producing new URLs, and each row records the platform that returned it, the rank it held there, and the destination page as Markdown when the page could be read.

Nothing is blended. A page returned by four platforms arrives as four rows sharing one `url`, so agreement between platforms is something you count rather than something the Actor asserts.

What it does not do: it returns the organic result blocks and any sponsored rows a platform prints above them, flagged with `is_ad`; it does not return shopping units, People Also Ask panels, knowledge panels or per-country targeting. It is not affiliated with any platform it reads. Brave documents an [independent index](https://brave.com/search/) and DuckDuckGo states that its [traditional links are largely sourced from Bing](https://duckduckgo.com/duckduckgo-help-pages/results/sources/); both result sets are kept with their platform labels so you can measure the overlap yourself.

### How do I run Multi Engine Search API?

1. Open the Actor. All three inputs arrive prefilled with a working example, so the first run needs no editing.
2. Set `keyword` to your search phrase and `max_results` to the rows you want **from each platform you select**.
3. List specific platforms in `platforms`, or clear the field to query all ten.
4. Press **▷ Start**, then read the Dataset tab or export to JSON, CSV, XLSX, XML or HTML.

The smallest useful runnable input:

```json
{
  "keyword": "web scraping api",
  "max_results": 2,
  "platforms": ["bing"]
}
```

Result limits apply **per platform, per run**: ten platforms at `max_results` 20 return up to 200 rows. Rows are written the moment their page has been read, so they arrive in reading order; sort by `platform` and `position` afterwards.

### What data does Multi Engine Search API return?

One row is one result from one platform, with the destination page read when it could be. Every row carries the same 13 fields.

| Field | Type | Description |
| --- | --- | --- |
| `title` | string or null | Result headline as the platform rendered it |
| `snippet` | string or null | Description the platform printed under the result, when it printed one |
| `url` | string or null | Result address, and the key to group on when comparing platforms |
| `source_name` | string or null | Publisher or site name the platform credited, when it showed one |
| `date_text` | string or null | Freshness text exactly as the platform printed it, unnormalized |
| `platform` | string or null | Which platform returned this result |
| `position` | integer or null | Organic rank on that platform; sponsored rows carry null |
| `is_ad` | boolean or null | Whether the platform served the row as a paid placement |
| `markdown` | string or null | The result page rendered as Markdown when it could be read |
| `word_count` | integer or null | Words in that Markdown rendering |
| `content_status` | string or null | `ok`, `empty`, `too_large`, `unconvertible` or `unavailable` |
| `processor` | string or null | Actor URL that produced the row |
| `processed_at` | string or null | UTC timestamp when the row was produced |

An abbreviated row from the `web scraping api` scenario, with `markdown` truncated to one line:

```json
{
  "title": "15 Best Web Scraping APIs in 2026 for Developers - Geekflare",
  "snippet": "Aug 11, 2026 · This post will go through the top managed web scraping APIs that will help you scrape webpages into Markdown, …",
  "url": "https://geekflare.com/guides/best-web-scraping-apis/",
  "source_name": null,
  "date_text": null,
  "platform": "bing",
  "position": 2,
  "is_ad": false,
  "markdown": "[Skip to content](#main-content)\n\n* [Products](https://geekflare.com) ...",
  "word_count": 3367,
  "content_status": "ok",
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-09-04T04:29:57+00:00"
}
```

A value the platform did not print stays empty: `snippet` is absent on image and video results, `source_name` and `date_text` appear only where shown, and `markdown` is empty whenever `content_status` is not `ok`.

### What inputs can I configure?

Three public inputs, in schema order. `keyword` and `max_results` are required; `platforms` is optional.

| Input | Type | Required | Description |
| --- | --- | --- | --- |
| `keyword` | string | Yes | The search phrase, passed to every selected platform exactly as sent. No platform-specific syntax is added or removed. |
| `max_results` | integer | Yes | Rows to return from each selected platform. Minimum 1, no maximum; each platform is paged until it has that many distinct URLs or stops producing new ones. |
| `platforms` | array | No | Which of the 10 platforms to search: `google`, `bing`, `baidu`, `yandex`, `naver`, `sogou_weixin`, `seznam`, `so360`, `duckduckgo`, `brave`. Empty queries all ten. |

A platform name this build no longer serves is skipped with a notice and the rest of the selection still runs.

### What platforms and markets does Multi Engine Search API cover?

Ten platforms across several language markets: Google, Bing, DuckDuckGo and Brave cover the general web; Baidu and So.com the Chinese web; Yandex the Russian web; Naver the Korean web; Seznam the Czech web; and Sogou's WeChat search reaches public articles inside that ecosystem that no general crawler holds.

Coverage per query is source-dependent: a platform may return nothing outside its market, and the run reports that separately from a platform that did not respond. Nine of the ten support a page parameter and the run walks it; DuckDuckGo's lightweight interface contributes one page.

### Why use Multi Engine Search API?

Breadth with the bookkeeping already done: one request, one response shape, every row traceable to its platform and rank.

| Capability | What it gives you |
| --- | --- |
| Ten platforms in one call | One request and one response shape, not ten layouts and ten page parameters |
| Per-platform ranking | Every row carries the platform that returned it and the rank it held there |
| Verifiable agreement | Group by `url`: the group size is the corroboration count |
| Per-platform budgets | Equal depth from every platform, rather than one loud platform consuming a shared total |
| Page text included | Ranking and page Markdown in one row, so a retrieval pipeline needs one pass |
| Ads made explicit | Sponsored rows carry `is_ad: true` and a null `position` |

The trade-off: fewer columns per result than a single-platform SERP product — no related questions, feature panels or per-country rank.

### Who is Multi Engine Search API for?

Developers and data teams building retrieval, monitoring or research pipelines that need more than one search platform behind them.

- **Retrieval and grounding pipelines** — a URL list and every readable page as Markdown in one call, with the per-`url` row count as a corroboration filter.
- **Cross-market SEO visibility** — pivot `platform` against `position` for your own domain to get a rank table across markets a single-platform tracker cannot see.
- **Regional research** — the Chinese, Russian, Korean or Czech web, answered by the platforms that actually crawl them.
- **Long-tail discovery** — pages returned by exactly one platform are often the most interesting part of the result set.

Not for you if you need shopping listings, SERP feature panels, per-country targeting, or one platform with maximum per-result detail.

### How can I use Multi Engine Search API through the API or MCP?

Use the Actor ID `vWEeCpz09B2M4NoTQ` in API clients and integrations; the `truefetch/multi-engine-search-api` name form resolves to the same Actor and is what an MCP client selects. Start the run, poll it, then read the Dataset; this asynchronous flow is the production path because a run is never bounded by one HTTP connection ([Apify runs and builds](https://docs.apify.com/platform/actors/running/runs-and-builds)).

```bash
RUN=$(curl -s -X POST "https://api.apify.com/v2/acts/vWEeCpz09B2M4NoTQ/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword":"web scraping api","max_results":2,"platforms":["bing"]}' \
  | python -c "import sys,json; print(json.load(sys.stdin)['data']['id'])")

curl -s "https://api.apify.com/v2/actor-runs/$RUN?token=APIFY_TOKEN"

curl -s "https://api.apify.com/v2/actor-runs/$RUN/dataset/items?token=APIFY_TOKEN"
```

Poll the second call until `data.status` is `SUCCEEDED`, or register an `ACTOR.RUN.SUCCEEDED` webhook. Generated SDK and OpenAPI examples are on the [Actor API page](https://apify.com/truefetch/multi-engine-search-api/api).

Quick test only: `POST /v2/acts/vWEeCpz09B2M4NoTQ/run-sync-get-dataset-items` returns rows on one connection, safe here only because a two-result run finishes well under the limit. The platform cuts a sync connection at 300 seconds without aborting the run, a client-side timeout never stops a billed run, and each client or gateway retry starts another billed run.

For MCP, point a client at `https://mcp.apify.com` and call the Actor by name:

```json
{
  "actor": "vWEeCpz09B2M4NoTQ",
  "input": {
    "keyword": "web scraping api",
    "max_results": 2,
    "platforms": ["bing"]
  }
}
```

### How much does Multi Engine Search API cost?

Each row costs $0.00250 on the FREE tier. At the configured 1 GB memory, Actor Start is $0.01 and two rows from one platform total $0.01500.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | --- | --- | --- | --- | --- | --- |
| Result (one row) | $0.00250 | $0.00225 | $0.00200 | $0.00188 | $0.00188 | $0.00188 |
| Actor Start (per GB of run memory) | $0.01 | $0.01 | $0.01 | $0.01 | $0.01 | $0.01 |

The billing unit is one Dataset row, and `max_results` is per platform, so the ceiling is exact: ten platforms at 12 is at most 120 rows. A page five platforms returned is five rows and is billed as five; sponsored rows count toward `max_results` and are billed like any other row. Actor Start is charged once per gigabyte of run memory with a minimum of one event; this Actor is configured for 1 GB, so one start event costs $0.01 on every tier. Reading the result page carries no separate charge, and a page several platforms returned is downloaded once.

Prices can change; live figures are on the [Actor pricing page](https://apify.com/truefetch/multi-engine-search-api/pricing).

### How does Multi Engine Search API compare with alternatives?

**Querying each platform by hand** works for one phrase against one platform and does not scale to ten, leaving no rank comparison and no export.

**Building the integration yourself** means ten response shapes, ten paging parameters and per-platform redirectors that hide the destination — recurring work, since those layouts change independently.

**The platforms' own official APIs** are the honest comparison and are better when one platform is enough: richer per-result data, documented quotas, provider support. None of them reaches another company's results.

**Single-platform SERP products** trade breadth for depth. Choose one for a single market and platform, or if you need feature panels or per-country targeting.

### What are the limits and troubleshooting steps?

- **Fewer rows than `max_results`** — the selected platforms hold no more distinct pages for that phrase. Select more platforms or broaden it.
- **The log names a platform that produced nothing** — reported separately from a platform that did not respond, so you can tell an empty market from an outage.
- **Sponsored rows arrived where you expected the ranking** — the platform printed ads above the organic block and `max_results` filled from the top. Raise `max_results` or filter the export on `is_ad`.
- **`sogou_weixin` returns unfamiliar results** — that platform covers WeChat articles, not the general web. Deselect it for web pages only.
- **DuckDuckGo returns one page only** — its lightweight interface has no page-forward for this request. Select other platforms for depth.
- **A `url` still looks like a platform's own address** — a few platforms publish a redirector whose destination cannot be recovered without following it. The link still reaches the page.
- **`content_status` is not `ok`** — the page refused the fetch, was too large, was empty or held no convertible text. The search row is still returned.
- **Two runs of the same phrase differ** — search rankings are not stable, which is why `processed_at` is stamped on every row.

Report a bug on the Issues tab with the run ID, exact input JSON and selected platforms; do not paste API tokens.

### Frequently asked questions

#### Can I search bing baidu and yandex from one api call?

Yes. Set `platforms` to `["bing","baidu","yandex"]` and all three are queried in parallel from one run. A page all three returned arrives as three rows sharing a `url`, each carrying that platform's own rank.

#### Is there a web search api with results from multiple indexes?

That is what this Actor is: ten web search platforms queried in one call, returned as rows in one Dataset with one response shape instead of ten result sets to reconcile.

#### Is there a free web search API?

Several platforms publish official APIs with free tiers, better when one platform is enough. This Actor adds the breadth: ten platforms in one call and one schema, which no single-platform API offers.

#### Can I schedule runs to monitor search results over time?

Yes. Apify's Scheduler runs the Actor on a cron expression, and because every row carries `processed_at`, consecutive runs build a rank history across markets a single-platform tool cannot see.

#### How do I see which pages several platforms agreed on?

Group the Dataset by `url`. A page returned by five platforms is five rows sharing that `url`, each with its own `platform` and `position`, so the group size is the agreement count.

#### Are sponsored results included?

Yes, when a platform prints them. They carry `is_ad: true` and a null `position`, so they never enter the organic ranking, and one filter on `is_ad` leaves you the organic set.

### Related TrueFetch Actors

- **[Google Trends Explore](https://apify.com/truefetch/google-trends-explore)** — measures demand for a phrase, which pairs with the supply side this Actor returns.
- **[Google Trending Now](https://apify.com/truefetch/google-trending-now)** — surfaces rising queries worth running across ten platforms before they are widely covered.
- **[Reddit Search API](https://apify.com/truefetch/reddit-search-api)** — searches discussion rather than the indexed web, for questions where forum answers beat pages.

### Support

[Store listing](https://apify.com/truefetch/multi-engine-search-api), [API reference](https://apify.com/truefetch/multi-engine-search-api/api) and [pricing](https://apify.com/truefetch/multi-engine-search-api/pricing). Report reproducible bugs on the Issues tab with the run ID and exact input JSON; ask questions in the [TrueFetch community on Telegram](https://t.me/TrueFetch).

[**Run a two-result test**](https://apify.com/truefetch/multi-engine-search-api) · [**View API**](https://apify.com/truefetch/multi-engine-search-api/api)

**Last Updated:** September 3, 2026

# Actor input Schema

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

The search phrase, sent to every selected platform exactly as you type it. No platform-specific syntax is added or removed.

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

How many rows to return from each platform you select. Minimum 1 with no maximum, and every selected platform gets the same budget, so ten platforms at 20 can return up to 200 rows. Each platform is paged until it has that many distinct result URLs or stops producing new ones. A page several platforms returned is one row per platform, each carrying that platform's own rank.

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

Which platforms to search, from 10 options: google, bing, baidu, yandex, naver, sogou_weixin, seznam, so360, duckduckgo and brave. Leave it empty to search all ten. A name this build no longer serves is skipped with a notice and the rest of the selection still runs.

## Actor input object example

```json
{
  "keyword": "web scraping api",
  "max_results": 2,
  "platforms": [
    "bing"
  ]
}
```

# Actor output Schema

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

Table view of every result with its platform and rank.

# 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": "web scraping api",
    "max_results": 2,
    "platforms": [
        "bing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/multi-engine-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": "web scraping api",
    "max_results": 2,
    "platforms": ["bing"],
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/multi-engine-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": "web scraping api",
  "max_results": 2,
  "platforms": [
    "bing"
  ]
}' |
apify call truefetch/multi-engine-search-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/multi-engine-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/vWEeCpz09B2M4NoTQ/builds/15cbST031be1EOG6t/openapi.json