# Multi-Engine SERP Scraper: Bing, DuckDuckGo, Baidu, Yahoo (`nomad-agent/serp-multi-engine-scraper`) Actor

Batch keyword searches across Bing, DuckDuckGo, Baidu and Yahoo. Export flat JSON rows with query, engine, organic rank, URL and snippet. Set a shared result cap, language and region. No search-engine API key. Yahoo requires residential proxy; Google is not supported.

- **URL**: https://apify.com/nomad-agent/serp-multi-engine-scraper.md
- **Developed by:** [Nomad.Devs](https://apify.com/nomad-agent) (community)
- **Categories:** SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 31 total users, 9 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 serp 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 SERP Scraper - Batch Keywords & Ranks

Batch keyword searches across Bing, DuckDuckGo, Baidu and Yahoo into comparable rows with query, engine, rank, URL and snippet. The result cap is shared across the batch. No search-engine API key is required; Yahoo needs a Residential proxy. Google is not supported; linked-page text is not fetched.

### Start with one input and output

An Apify account is required. Use your Apify API token when calling the API; Console runs do not need that token pasted into the input. No search-engine key or login is required. Yahoo needs an Apify Residential proxy; Google is not supported.

Free-tier event rates checked 2026-10-04: `result` $0.001; `actor-start` $0.001. Scale and Business plans pay less per `result` event: $0.375 and $0.25 per 1,000.

**Cost:** Total = Actor event charges + platform usage if separately billed + any BYO-provider charges. See “Current costs” for your event rates, plan tiers and a calculation. A sample does not promise future billable volume.

Input and output below were read from the same successful run `tpewRF529CUoRNMa0` (2026-09-18, immutable build `tjtJANwwaEkZErFzL`). This is an observed example, not a guarantee that repeating it returns this row. It used an earlier build; current-build execution has not been proved by this example.

**Input JSON**

```json
{
  "queries": [
    "open source search engine"
  ],
  "engines": [
    "bing"
  ],
  "maxItems": 3,
  "device": "desktop",
  "maxPagesPerQuery": 1,
  "resultsPerPage": 0,
  "includeAds": false,
  "concurrency": 4
}
```

**Matching output excerpt**

Long strings and arrays are shortened for display; this is not a complete dataset fixture.

```json
{
  "query": "open source search engine",
  "engine": "bing",
  "rank": 1,
  "page": 1,
  "title": "7 Open - Source Search Engines for your Enterprise and Startups you …",
  "url": "https://www.bing.com/ck/a?!&&p=703661c6c7d6aef7c8e3fae9c043330f8613e60599c877d7a4900d39534e8164JmltdHM9MTc4OTY4OTYwMA&ptn=3&ver=2&hsh=4&fclid=1c69d390-327c-6bae-26a1-c448333d6a4d&u=a1aHR0cHM6Ly9kZXYudG8vc3dpcmwvNy1vcGVuLXNvdXJjZS1zZWFyY2gtZW5naW5lcy1mb3IteW91ci1lbnRlcnByaXNlLWFuZC1zdGFydHVwcy15b3UtbXVzdC1rbm93LTQ1MDQ&ntb=1",
  "snippet": "Oct 4, 2023 · Open-source search engines are critical because they offer freedom and data privacy and are self-hosted. Let’s talk …",
  "ad": false,
  "serpUrl": "https://www.bing.com/search?q=open+source+search+engine",
  "device": "desktop",
  "resultsTotal": 15100
}
```

Scrape organic search results from **the four engines Google-only scrapers ignore** — Bing, DuckDuckGo, Baidu and Yahoo — in a single run. Pass your queries, pick engines, get clean structured JSON: title, URL, snippet, rank, page, engine tag and the engine's estimated total-results count. Language/region targeting, native pagination, optional desktop/mobile device targeting. No API keys, no login, no browser.

> **Claude / Codex skill to describe and setup this actor: [SKILL.md](https://github.com/Exdenta/OinkAIJobSearch/blob/main/skill/serp-multi-engine-scraper/SKILL.md)**

**Supported engines:** Bing, DuckDuckGo, Baidu and Yahoo. Google is not supported. Compare current prices and engine coverage before choosing a tool.

Engine parsers ported from the MIT-licensed [openserp](https://github.com/karust/openserp) project (see `NOTICE`).

### What SERP data does this scraper extract?

Each result is one flat JSON record per organic (or ad, if enabled) result:

| Field | Meaning |
|---|---|
| `query` | The search query this result came from |
| `engine` | Engine that returned it: `bing`, `duckduckgo`, `baidu`, `yahoo` |
| `rank` | 1-based organic rank within (query, engine), across pages |
| `page` | 1-based SERP page number |
| `title` | Result title as shown on the SERP |
| `url` | Target URL (redirect wrappers unwrapped where possible) |
| `snippet` | Description / snippet text |
| `ad` | `true` when the result is a sponsored/ad slot |
| `serpUrl` | The exact SERP URL that was fetched (for reproducibility) |
| `device` | Device profile used for the request: `desktop` or `mobile` (echoes the `device` input; see [Device targeting](#device-targeting) below) |
| `resultsTotal` | The engine's own estimated total number of matches for the query (e.g. Bing's "About 1,230,000 results"). Best-effort — populated for `bing` and `baidu` when the SERP shows a count header; `null` for `duckduckgo` / `yahoo` (no count header) and whenever the header wasn't present |

Every field above is present on every row (flat schema, no nested objects, no permanently-empty columns) — this keeps CSV/Excel exports clean.

### How to scrape search engine results with this Actor

1. Click **Try for free** / **Run** — no login to any search engine, no cookies.
2. Enter one or more `queries`, tick the `engines` you want, optionally set `languageCode` / `region` / `maxPagesPerQuery`.
3. Run it and export the dataset as JSON, CSV or Excel, or read it over the [API](https://docs.apify.com/api/v2).

Run it from your own code:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nomad-agent/serp-multi-engine-scraper").call(run_input={
    "queries": ["best python web framework"],
    "engines": ["bing", "duckduckgo", "baidu"],
    "maxPagesPerQuery": 2,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["engine"], item["rank"], item["title"], item["url"])
```

Or a single HTTP call that runs the Actor and returns items in one response:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nomad-agent~serp-multi-engine-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["best python web framework"], "engines": ["bing", "duckduckgo"]}'
```

**Integrations:** export the dataset as JSON, CSV or XLSX from the Console; call it synchronously with [`run-sync-get-dataset-items`](https://docs.apify.com/api/v2#/reference/actor-tasks/run-collection/run-task-synchronously) as shown above; wire it into Make, Zapier or n8n via their Apify connector; or drive it from any AI agent through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `queries` | array | — | Search queries, one per entry. Inline operators like `site:` and `filetype:` work. **Required.** |
| `engines` | array | `["bing","duckduckgo"]` | Any of `bing`, `duckduckgo`, `baidu`, `yahoo`. |
| `device` | string | `"desktop"` | `desktop` or `mobile`. Only changes behavior on Bing — see [Device targeting](#device-targeting). Other engines accept and ignore it. |
| `languageCode` | string | `""` | BCP-47 code (`en`, `de`, `pt-BR`). Mapped per engine: Bing `mkt/setlang/cc`, DuckDuckGo `kl`, Yahoo `vl`. Baidu takes no language param. |
| `region` | string | `""` | Country hint: two-letter code for Bing (`cc`), e.g. `de`, `gb`. Ignored by engines without a region param. |
| `maxPagesPerQuery` | integer | `1` | SERP pages per query per engine, via each engine's native offset param. Stops early on empty/blocked pages. Max `10`. |
| `resultsPerPage` | integer | `0` | Results per page where supported (Bing `count`, Baidu `rn`, Yahoo `n`). `0` = engine default. Max `50`. |
| `maxItems` | integer | `100` | Hard cap on total results pushed across all queries and engines, **shared evenly across your queries** so none is starved. **Each result returned is billed as one dataset item** — see Pricing below. `0` = no cap (costs then scale with queries × engines × pages — use with care). Max `1000`. |
| `includeAds` | boolean | `false` | Include sponsored results (tagged `"ad": true`). |
| `proxyConfiguration` | object | off | Optional. Yahoo needs Apify `RESIDENTIAL` proxy; Bing, DuckDuckGo and Baidu work without one. |
| `concurrency` | integer | `4` | *(Advanced)* How many searches run at the same time. Higher is faster but more likely to get rate-limited. Extra pages within one search are always fetched one at a time with a short delay, regardless of this setting. Max `8`. |

### Output example

Real `push_data` shape, captured from a live run:

```json
{
  "query": "open source search engine",
  "engine": "duckduckgo",
  "rank": 1,
  "page": 1,
  "title": "Home - OpenSearch",
  "url": "https://opensearch.org/",
  "snippet": "OpenSearch is an open-source search and analytics suite…",
  "ad": false,
  "serpUrl": "https://html.duckduckgo.com/html/?q=open+source+search+engine&kl=us-en",
  "device": "desktop",
  "resultsTotal": null
}
```

`resultsTotal` is `null` on DuckDuckGo and Yahoo — neither renders a total-match count on the endpoints this Actor reads.

### Pricing

Pay per event — no subscription, no rental, you pay only for what you fetch.

| | Actor start | Per result | 1,000 results |
|---|---|---|---|
| **Current** (from 18 September 2026) | $0.001 | $0.001 | **$1.00** |

Store discounts apply automatically on paid Apify plans — the higher your plan, the cheaper each result, with no action needed on your side:

| Apify plan | Per result | 1,000 results |
|---|---|---|
| Free | $0.001 | $1.00 |
| Starter | $0.0009 | $0.90 |
| Scale | $0.0007 | $0.70 |
| Business and above | $0.0005 | **$0.50** |

Only results the Actor actually pushed are billed. A blocked engine, a filtered-out ad and an empty SERP page all cost you nothing, and `maxItems` (default `100`) is a hard ceiling on what a single run can bill you for.

What that works out to in practice:

| Job | Results | Cost |
|---|---|---|
| Spot check — 1 query, 1 engine, 1 page | 10 | $0.011 |
| Daily rank track — 20 keywords, Bing + DuckDuckGo | 400 | $0.401 |
| Full sweep — 50 keywords, all four engines | 2,000 | $2.001 |

The actor-start fee was cut from $0.005 to $0.001 on 18 September 2026, because on a rank-tracking run — ten results per keyword — a start fee that size was a third of the bill.

### Use cases

- Rank tracking / SEO monitoring on the engines Google-only tools miss
- Bing rank tracking — the engine behind Microsoft Copilot's web answers
- Baidu (China) and Yahoo (Japan) SERP snapshots for regional SEO
- Comparing result overlap between Bing, DuckDuckGo, Baidu and Yahoo
- Regional / language SERP snapshots (`languageCode` + `region`)
- Feeding organic results into research, lead-gen or LLM pipelines
- Cheap keyword-to-URL discovery without a paid SERP API

### Engines & reliability

| Engine | Proxy needed? | Notes |
|---|---|---|
| Bing | No | HTML first, automatic RSS-output fallback when Bing serves its JS bot-wall |
| DuckDuckGo | No | Uses the JS-free `html.duckduckgo.com` endpoint |
| Baidu | No | Real target URLs taken from the result `mu` attribute where present |
| Yahoo | **Yes — residential** | Returns nothing from Apify's datacenter IPs. Enable Apify Proxy (`RESIDENTIAL`) and it works. `r.search.yahoo.com` redirect wrappers are unwrapped to the real target URL |

Every page that comes back blocked or empty is retried once on a fresh session before the Actor gives up on it. Engines that stay blocked are logged and skipped — they never fail the run, and you are never charged for results that were not returned.

#### Why Google, Yandex and Ecosia are not offered

They were, and they never worked. All three captcha-wall a plain HTTP request — verified from Apify datacenter IPs **and** from a residential IP:

| Engine | What it actually returns |
|---|---|
| Google | JS-required interstitial (soft block), on every IP tried |
| Yandex | HTTP 200, but redirected to `showcaptchafast` (SmartCaptcha) |
| Ecosia | HTTP 403 bot challenge |

Getting past those needs a headless browser plus captcha solving — a different and much more expensive Actor. Rather than list three engines that bill you for a guaranteed-empty run, this Actor does not offer them at all.

### Device targeting

The `device` input (`desktop` / `mobile`) is real, not a cosmetic toggle — but it only does something on the engine that actually responds differently to it:

| Engine | `device: mobile` effect |
|---|---|
| Bing | **Real, verified.** Switches to a mobile browser User-Agent. This also helps get past Bing's JS bot-wall page that otherwise blocks datacenter IPs (mobile UA returned real results directly in testing; desktop UA needed the RSS fallback). |
| DuckDuckGo | **No-op.** The `html.duckduckgo.com` endpoint this Actor uses is a single, JS-free layout with no separate mobile version. The field is accepted but ignored. |
| Baidu / Yahoo | **No-op.** Not implemented. The field is accepted but ignored; it never causes an error. |

### Related searches & People Also Ask

**Not implemented on any engine, and not a dataset field.** On all four engines the related-searches and "People also ask" widgets are lazy-loaded by JavaScript after the initial response — the static HTML this Actor fetches never contains them, so there is nothing to parse. Adding the fields would only ever give you permanently-empty columns.

If you need People Also Ask, it is a Google feature in practice, and [Apify's Google Search Scraper](https://apify.com/apify/google-search-scraper) extracts it.

### FAQ

**Is it legal to scrape search engine results?**
This Actor reads only publicly available SERP data — what any visitor sees without logging in. No personal data behind authentication is touched. Review the target engines' terms and your local regulations for your specific use case.

**Do I need an account or API key?**
No. Results are fetched from public SERP pages — no login, no API keys, no cookies.

**Can I scrape Google with this?**
No — and that is deliberate, not a limitation being hidden. Google captcha-walls plain HTTP requests from every IP, so offering it would just bill you for empty runs. See [Why Google, Yandex and Ecosia are not offered](#why-google-yandex-and-ecosia-are-not-offered). Use [Apify's Google Search Scraper](https://apify.com/apify/google-search-scraper) for Google and this Actor for everything else.

**Why does Yahoo return no results?**
Yahoo is the one engine here that needs a proxy: it returns nothing from Apify's datacenter IPs. Enable Apify Proxy with the `RESIDENTIAL` group in `proxyConfiguration`. Bing, DuckDuckGo and Baidu need no proxy at all.

**How many results can I get?**
Up to `maxPagesPerQuery` pages per engine per query (~10 results/page, ~25 for DuckDuckGo), capped by `maxItems` (default `100`, max `1000`). The cap is shared out evenly across your queries, so every query gets results — it is never drained by whichever query happens to run first. Each result is billed as one dataset item — see Pricing above.

**Are ads included?**
Only when `includeAds` is on; ad rows are tagged `"ad": true` and never consume organic ranks.

**Can I get mobile search results?**
Yes for Bing: set `device` to `mobile`. It's a no-op on DuckDuckGo, Baidu and Yahoo — see [Device targeting](#device-targeting).

**Does this Actor extract related searches or People Also Ask?**
No — on all four engines those widgets are JavaScript-rendered after page load, so a plain HTTP fetch never receives them. See [Related searches & People Also Ask](#related-searches--people-also-ask).

**Something broken or missing?**
Search engines change their markup often. Open an issue on the Actor's **Issues** tab — it is monitored and reliability fixes ship fast.

### Attribution

SERP URL construction and CSS selectors are a Python port of [openserp](https://github.com/karust/openserp) by Rustem Kamalov, MIT License. See `LICENSE` and `NOTICE`.

**Is this Actor useful to you?**
A quick ⭐ review on the Actor's **Reviews** tab helps other SERP and search-data users find it — and tells us what to build next.

### Product guides and related tools

- [Product overview and public links](https://jobatlas.dev/actors/directory/data-tools#nomad-agent-serp-multi-engine-scraper)
- [Public setup guide](https://github.com/Exdenta/jobatlas/blob/main/docs/public-actors-setup.md)

### Current costs

Current Actor event rates, checked 2026-10-16. USD; use the **Pricing** tab for your plan and later changes.

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---:|---:|---:|---:|---:|---:|
| SERP result (`result`) | $0.0005 | $0.0005 | $0.000375 | $0.00025 | $0.00025 | $0.00025 |
| Actor start (`actor-start`) | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 |

For example, 100 × `result`, 1 × `actor-start` totals **$0.101 in Actor event charges on Free**. This is an arithmetic example, before any waiver; actual charged events depend on the run and selected options. It is not a promise of output or a charge for simply setting an item cap.

Your total is the charged Actor events, plus platform usage **only if this Actor’s Pricing tab bills it separately**, plus any external provider you use with your own key. Do not add platform usage twice when it is included. Apify credits and plan discounts affect your invoice. Set a run cost limit in Console before starting.

# Actor input Schema

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

Search queries to run, one per entry. Search operators like site: and filetype: work inline (e.g. <code>annual report filetype:pdf site:example.com</code>).

## `engines` (type: `array`):

Engines to query — every result row is tagged with the engine it came from. Bing, DuckDuckGo and Baidu need no proxy. Yahoo returns nothing from datacenter IPs unless you enable Apify residential proxy below. A blocked engine is logged and skipped, never fails the run.

## `device` (type: `string`):

Search as a desktop or mobile browser. Only Bing actually changes its response based on this (a mobile signal also helps avoid its bot-block page). The other engines accept the field but ignore it — see the <code>Device support</code> table in the README.

## `languageCode` (type: `string`):

BCP-47 language code, e.g. <code>en</code>, <code>de</code>, <code>pt-BR</code>. Mapped per engine: Bing mkt/setlang/cc, DuckDuckGo kl, Yahoo vl. Baidu does not take a language param.

## `region` (type: `string`):

Country hint. Two-letter code for Bing (cc), e.g. <code>de</code>, <code>gb</code>. Ignored by engines without a region param.

## `maxPagesPerQuery` (type: `integer`):

SERP pages to fetch per query per engine. Pagination uses each engine's native offset param (Bing first, DuckDuckGo s, Baidu pn, Yahoo b). Stops early when a page is empty or blocked.

## `resultsPerPage` (type: `integer`):

Results requested per page where the engine supports it (Bing count, Baidu rn, Yahoo n). 0 = engine default (~10, DuckDuckGo ~25).

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

Hard cap on total results pushed across all queries and engines. The cap is shared out evenly across your queries (round-robin), so every query gets results — it is never drained by the first query alone. Each result returned is billed as one dataset item — see Pricing in the README. 0 = no cap (costs then scale with queries × engines × pages; use with care).

## `includeAds` (type: `boolean`):

Include sponsored/ad results (marked with <code>ad</code>: true). Off = organic results only.

## `proxyConfiguration` (type: `object`):

Optional proxy. Bing, DuckDuckGo and Baidu work fine without one. Yahoo returns nothing from Apify's datacenter IPs — enable Apify Proxy with the RESIDENTIAL group to scrape it. A proxy also reduces rate limiting on long multi-query runs.

## `concurrency` (type: `integer`):

How many searches to run at the same time. Higher is faster but more likely to get rate-limited or blocked by a search engine. Extra pages within a single search are always fetched one at a time with a short delay between them, regardless of this setting.

## Actor input object example

```json
{
  "queries": [
    "best python web framework",
    "rust async runtime comparison"
  ],
  "engines": [
    "bing",
    "duckduckgo"
  ],
  "device": "desktop",
  "languageCode": "en",
  "region": "de",
  "maxPagesPerQuery": 1,
  "resultsPerPage": 0,
  "maxItems": 100,
  "includeAds": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "concurrency": 4
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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": [
        "open source search engine"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nomad-agent/serp-multi-engine-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 = {
    "queries": ["open source search engine"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("nomad-agent/serp-multi-engine-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 '{
  "queries": [
    "open source search engine"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call nomad-agent/serp-multi-engine-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nomad-agent/serp-multi-engine-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/pC7aLjYo7nTZE7nWO/builds/2mLBBP1QQ4jWxuBdt/openapi.json