# Google Ads Transparency Scraper (`atkvn/google-ads-transparency-scraper`) Actor

Export the ads any advertiser runs on Google (Search, YouTube, Display, Shopping, Maps) from the Ads Transparency Center by name, domain or ID, with region, date and format filters, ad details, and a monitor mode that returns only new ads on scheduled runs.

- **URL**: https://apify.com/atkvn/google-ads-transparency-scraper.md
- **Developed by:** [Dong Nguyen](https://apify.com/atkvn) (community)
- **Categories:** Marketing, Lead generation, SEO tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 ads

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 Ads Transparency Center Scraper

Export the ads any company runs on Google — Search, YouTube, Display, Shopping, Maps — from Google's public [Ads Transparency Center](https://adstransparency.google.com). Give it advertiser names, domains, advertiser IDs or Transparency Center URLs and get one clean row per ad: who ran it, the format, when it first and last ran, where, and a link to the creative.

No login, no cookies, no browser. The Actor reads the same public data the Transparency Center website shows.

### Who it is for

- **Marketers and agencies** — see every ad a competitor is running right now, how long each has been live, and which creatives they keep.
- **Competitive-intelligence teams** — track when a brand enters a country, which formats it favours, and how many creatives it rotates.
- **Weekly competitor watch** — turn on monitor mode, schedule the task, and each run returns only the creatives launched since the last one.
- **AI-agent builders** — a predictable JSON shape (every item has the same keys, `null` when unknown) that is safe to feed to a model or a pipeline.

### What you get per ad

| Field | Meaning | Needs `includeDetails` |
|---|---|---|
| `advertiserId`, `advertiserName` | Google's advertiser ID (`AR…`) and display name | no |
| `creativeId` | Google's ad ID (`CR…`) | no |
| `format` | `text`, `image` or `video` | no |
| `firstShown`, `lastShown` | First and last time Google served the ad (UTC) | no |
| `daysShown` | Number of days the ad was served | no |
| `landingDomain` | Domain the ad points to. Always filled for domain queries; for other queries only when it can be read from the creative | no |
| `previewUrl` | The creative: an image URL when Google stores a static rendering, otherwise Google's preview script URL | no |
| `imageUrl` | Static rendering of the ad, when one exists (most text ads, some image ads) | no |
| `transparencyUrl` | Link to the ad on the Transparency Center | no |
| `regions` | Countries (ISO codes) where the ad was shown. Without details: the region you filtered by, or `null` for "anywhere" | full list: yes |
| `regionStats` | Per country: first/last shown date, and impression range where Google publishes it | yes |
| `impressionsMin`, `impressionsMax` | Total impression range. Google only publishes this for ads shown in the EU and similar regulated regions; elsewhere `null` | yes |
| `variationCount`, `assetUrls` | Number of creative variations and the image URL of each; video thumbnails for video ads | yes |
| `videoUrl` | YouTube link for video ads | yes |
| `adText`, `adTextLines`, `displayUrl` | Visible ad copy. Only for text ads that Google serves as HTML — see limits below | yes |
| `advertiserLegalName`, `advertiserCountry`, `advertiserVerified` | Advertiser identity as shown by Google | yes |
| `query`, `queryType`, `detailsFetched`, `scrapedAt` | Which input produced the row, how it was interpreted, whether details were loaded, and when | no |

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `queries` | array of strings | — (required) | Domain, advertiser name, advertiser ID or Transparency Center URL. Mix freely. |
| `region` | string | `anywhere` | ISO country code (`US`, `GB`, `DE`, `VN` …) or `anywhere`. |
| `dateFrom`, `dateTo` | `YYYY-MM-DD` | none | Only ads shown in this window. |
| `format` | `all` / `text` / `image` / `video` | `all` | |
| `platform` | `all` / `search` / `youtube` / `maps` / `play` / `shopping` | `all` | Only ads shown on that Google platform — the Transparency Center's own Platform filter. Google applies it to ads shown since 4 Sep 2023 only. |
| `maxAdsPerQuery` | integer | `100` | `0` = no limit. |
| `includeDetails` | boolean | `false` | Adds the detail fields above. One extra request and one extra charge per ad; much slower. |
| `onlyNewAds` | boolean | `false` | Monitor mode: return and charge only ads this monitor has not returned before and that were first shown since its last run. See below. |
| `monitorName` | string | `default` | Separate monitors keep separate memories, e.g. `brand-a-us`. |
| `maxAdvertisersPerName` | integer | `1` | For name queries: how many matching advertisers to include. |
| `maxRequestsPerSecond` | number | auto | Auto = 1 when listing, 0.25 with details. |
| `proxyConfiguration` | Apify proxy input | none | Optional. See "Rate limits" below. |

#### How each kind of query is handled

- **Domain** (`nike.com`) — ads from *every* advertiser that points ads at that domain (often several legal entities, resellers and affiliates). This is usually what you want for competitor research.
- **Advertiser ID** (`AR16735076323512287233`) — exactly that advertiser. The most precise option.
- **Advertiser name** (`Nike`) — resolved through Google's own suggestions to the advertiser whose name matches and who has the most ads (here: "Nike, Inc."). Names are ambiguous; the log and the `advertiserId` field tell you who was picked. Raise `maxAdvertisersPerName` or use the domain if you want them all.
- **Transparency Center URL** — an advertiser page, a single-ad page (`/advertiser/AR…/creative/CR…`, returns that one ad with details), or a `?domain=` search. Filters in the URL are ignored; the input fields apply.

#### Examples

Everything pointing at a competitor's domain in the US, up to 500 ads:

```json
{
  "queries": ["nike.com"],
  "region": "US",
  "maxAdsPerQuery": 500
}
```

Video ads of three brands in Germany during Q3, with details:

```json
{
  "queries": ["zalando.de", "AR01625195283841286145", "HubSpot"],
  "region": "DE",
  "format": "video",
  "dateFrom": "2026-07-01",
  "dateTo": "2026-09-30",
  "maxAdsPerQuery": 50,
  "includeDetails": true
}
```

One specific ad:

```json
{
  "queries": ["https://adstransparency.google.com/advertiser/AR15589870916631265281/creative/CR16333246845520183297?region=DE"]
}
```

### Output sample

A real item from a run on 19 November 2026 (`"queries": ["shopify.com"], "includeDetails": true`). `regionStats` is shortened here from 13 entries to 2; nothing else is edited.

```json
{
  "query": "shopify.com",
  "queryType": "domain",
  "advertiserId": "AR01625195283841286145",
  "advertiserName": "Shopify Inc.",
  "creativeId": "CR17723666237570940929",
  "format": "video",
  "firstShown": "2026-10-06T16:36:23Z",
  "lastShown": "2026-11-18T12:01:58Z",
  "daysShown": 44,
  "regions": ["DZ", "ZA", "EG", "LY", "NG", "ZW", "MA", "TZ", "KE", "UG", "TN", "GH", "SN"],
  "landingDomain": "shopify.com",
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&obfuscatedCustomerId=6178574835&creativeId=827208976688&uiFeatures=12,54&adGroupId=192321953246&assets=%3DH4sIAAAAAAAAAONy4uLkWPfiV8duHgEeLk6Olis9t3bxCDBzcXJ0QZiMXJwc7Qjm-51PPj5iF9Dk4uTovLRr8zwuATYAu27RUkQAAAA&sig=ACiVB_xhYFwoyhfNoDuB8wUxtmgHUg0HCQ&htmlParentId=fletch-render-1317732629125866294&responseCallback=fletchCallback1317732629125866294",
  "imageUrl": null,
  "videoUrl": "https://www.youtube.com/watch?v=acYbMCenDg8",
  "assetUrls": ["https://i.ytimg.com/vi/acYbMCenDg8/hqdefault.jpg"],
  "adText": null,
  "adTextLines": null,
  "displayUrl": null,
  "variationCount": 6,
  "regionStats": [
    { "region": "DZ", "firstShown": null, "lastShown": "2026-10-26", "impressionsMin": null, "impressionsMax": null },
    { "region": "EG", "firstShown": null, "lastShown": "2026-11-19", "impressionsMin": null, "impressionsMax": null }
  ],
  "impressionsMin": null,
  "impressionsMax": null,
  "advertiserCountry": "CA",
  "advertiserLegalName": "Shopify Inc.",
  "advertiserVerified": true,
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR01625195283841286145/creative/CR17723666237570940929?region=anywhere",
  "detailsFetched": true,
  "scrapedAt": "2026-11-19T13:01:43Z"
}
```

When a query cannot produce ads, the dataset gets a notice row instead of the run failing. Notice rows are never charged. Their shape:

```json
{
  "query": "zzqxqxnotexistingadvertiser",
  "queryType": "name",
  "errorType": "not_found",
  "error": "No advertiser matches 'zzqxqxnotexistingadvertiser'. Try the advertiser's domain or its AR… id.",
  "scrapedAt": "2026-11-19T13:30:00Z"
}
```

`errorType` is one of `invalid_query`, `not_found`, `no_results`, `request_failed`, `blocked`, `internal_error`.

### Monitor mode: only new ads

Set `onlyNewAds: true` and schedule the run (daily or weekly). The first run returns the current ads as usual and saves them as the baseline. Every later run returns only ads that

1. this monitor has not returned before, and
2. Google first showed on or after the previous run (minus a 2-day margin, because Google dates ads by day and publishes them with a delay).

Older ads and ads you already have are skipped before any detail lookup, so **they are never charged**. Google lists ads by the time they were last shown, newest first, so the Actor stops paging an advertiser once a whole page was last shown before the previous run.

The memory lives in your own named key-value store `google-ads-transparency-monitor`, one record per `monitorName` (the ad IDs plus the time of the last run). Delete the record to start a monitor over. Use one `monitorName` per task so two schedules never share a memory.

Tested live on 21 Nov 2026, `shopify.com`, region US, `maxAdsPerQuery: 20`, run twice a few minutes apart: run 1 returned 20 ads (the baseline); run 2 read 11 list pages without charge, skipped 20 known and 1,017 older ads, and returned 20 ads all first shown on 19–20 Nov 2026 — none of them from run 1.

### Use it from an AI agent (MCP)

Apify's hosted MCP server exposes this Actor as a tool, so Claude, Cursor, VS Code or any other MCP client can call it directly. Server URL:

```
https://mcp.apify.com/?tools=atkvn/google-ads-transparency-scraper
```

Authenticate with your Apify API token as a bearer header. In Claude Code, for example:

```bash
claude mcp add --transport http google-ads "https://mcp.apify.com/?tools=atkvn/google-ads-transparency-scraper" --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

The tool is called `atkvn--google-ads-transparency-scraper` and takes the same input as described above. It starts a normal run, so pricing and limits are the same. Tested on 21 Nov 2026 with two calls through the MCP server (`shopify.com`, 3 ads; `nike.com` with `platform: youtube`, 5 ads): both succeeded in under 6 seconds and were charged per ad as usual.

### Pricing

Pay per result, two events:

| Event | When it is charged |
|---|---|
| `ad` | Once for every ad row written to the dataset. |
| `ad-detail` | Once for every ad whose detail record was loaded (`includeDetails`). Not charged when the lookup fails. |

Notice rows, duplicates, retries and — in monitor mode — ads skipped as known or older cost nothing. If you set a maximum charge for the run, the Actor checks the remaining budget before each ad and stops cleanly when it is used up — it never does billable work it cannot deliver.

### Rate limits, speed and reliability — read this before a large run

- **Listing ads is fast and light.** One request returns up to 100 ads. In testing, 250 Nike ads took 4 requests and under 4 seconds.
- **No paging ceiling found.** On 21 Nov 2026 on the Apify platform, `Nike` in the US (Google reports 7,000–8,000 ads) was listed twice: 2,500 ads in 26 pages and 90 seconds, then with no limit 2,997 distinct ads in 30 pages and under 3 minutes, containing all 2,500 from the first run. The second run stopped only because it reached the run's maximum charge, not because Google stopped returning pages. For a full export of a large advertiser, set the maximum charge high enough (about 1.50 USD per 1,000 ads without details).
- **Details are slow on purpose.** Each ad needs its own request. In testing from a single IP address without a proxy, Google answered about 60 consecutive detail lookups at one per second and then started redirecting every request to its "unusual traffic" page; the address was still refused 42 minutes later, when testing stopped. The Actor therefore defaults to one detail request every 4 seconds, which means roughly 7 minutes per 100 ads with details. Whether that pace avoids the limit indefinitely has not been established.
- **What happens when Google rate limits a run:** without a proxy the Actor waits and retries twice, then stops, saves what it has, writes one `blocked` notice row and marks the run as failed with a clear message. It does not solve CAPTCHAs. Resurrecting the run later continues from the saved position without re-charging or duplicating ads. With plain Apify Proxy (the default) the Actor connects directly first and moves to the proxy only after Google refuses the direct connection, then retries each further refusal through a fresh proxy address. On 21 November 2026 Google refused Apify datacenter proxy addresses on 4 of 6 test runs while direct connections from the same platform answered, so the proxy is a fallback, not the first route. Choosing a proxy group or your own proxy URLs makes every request go through the proxy.
- **Transient errors** (timeouts, HTTP 5xx) are retried up to 5 times with exponential backoff.
- **No duplicates.** Each query keeps a set of the ads it already wrote; an ad is never written twice for the same query, including after a resume. The same ad can appear under two different queries (for example a domain and that advertiser's ID).

### Honest limits

- **Ad copy is usually not available as text.** Google serves most text ads in the Transparency Center as a picture of the ad. In a test run of 61 Shopify ads with details, 44 were text ads and only 1 had copy that could be read as text; the rest have an `imageUrl` you can view or pass to OCR / a vision model. `adText` is `null` in those cases — it is never guessed.
- **`landingDomain`** is filled for domain queries (100% in testing) and is usually `null` for advertiser-ID and name queries, because Google's list does not include it there.
- **Impressions** are ranges, published by Google only for ads shown in the EU and a few other regulated regions. No spend, clicks, targeting keywords or conversion data exist in the Transparency Center.
- **Image ads** that have no static rendering only expose a preview script URL in `previewUrl`; open `transparencyUrl` to see them.
- **Platform filter** (Search / YouTube / Shopping / Maps / Play) only covers ads shown since 4 Sep 2023, because that is all Google applies it to. Example from 21 Nov 2026: `nike.com` in the US gave 8,000–9,000 matching ads on all platforms and 3,000–4,000 with `platform: youtube`.
- **`advertiserVerified`** is read from a flag in Google's response that matched the site's "verified" badge on the advertisers checked; Google does not document it.
- **Totals are approximate.** Google reports the number of matching ads as a range (for example "7,000–8,000"); the log shows it at the start of each query.
- **This is an unofficial tool.** It depends on the Transparency Center's internal endpoints, which Google can change without notice. If a field starts coming back empty, open an issue.

### FAQ

**Do I need a Google account or API key?** No. The Transparency Center is public.

**Can I search by keyword, like "running shoes"?** No. The Transparency Center is organised by advertiser and by landing domain, not by ad keyword. Query the brands or domains you care about.

**Why does a domain query return advertisers I do not recognise?** A domain query returns every advertiser whose ads point at that domain: regional legal entities, agencies, resellers, affiliates. Filter by `advertiserId` or `advertiserName` afterwards, or query the advertiser ID directly.

**How far back does the data go?** As far as the Transparency Center shows for that advertiser. Use `dateFrom` / `dateTo` to narrow it.

**How do I monitor a competitor over time?** Turn on monitor mode (`onlyNewAds` with a `monitorName`, see above) and schedule the Actor, for example weekly: each run returns only ads first shown since the previous run, and ads it skips are not charged.

**Can I get more than `maxAdsPerQuery` allows?** Set it to `0` for no limit. For advertisers with tens of thousands of ads, split the work by `region`, `format`, `platform` or date range, and set a maximum charge.

**Can I run it on my own machine?** Yes:

```bash
python -m venv .venv && .venv/bin/pip install -r requirements.txt
echo '{"queries": ["nike.com"], "region": "US", "maxAdsPerQuery": 50}' > input.json
.venv/bin/python -m src --local --input input.json --output ads.jsonl
```

`--local` stores the dataset and resume state under `./storage` and needs no Apify account. Add `--resume` to continue an interrupted local run.

**Is this legal?** The Actor only reads data Google publishes for public transparency, without logging in. You are responsible for how you use the output; advertiser names can be names of individuals, so handle the data in line with the privacy rules that apply to you.

### Development

```bash
.venv/bin/pip install -r requirements-dev.txt
.venv/bin/python -m pytest                              # offline tests, real captured responses as fixtures
RUN_LIVE_TESTS=1 .venv/bin/python -m pytest tests/test_live.py   # one small live test (about 8 requests)
```

# Actor input Schema

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

One per line. Each entry can be a domain (nike.com), an advertiser name (Shopify), an advertiser ID (AR16735076323512287233) or a Transparency Center URL (advertiser page, single ad page, or a ?domain= search). A domain returns ads from every advertiser that points ads at that domain. A name is resolved to the best-matching advertiser - use the domain or the ID when you need to be exact.

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

Two-letter ISO country code (US, GB, DE, VN ...) to return only ads shown in that country, or "anywhere" for all regions.

## `dateFrom` (type: `string`):

Only ads shown on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

## `dateTo` (type: `string`):

Only ads shown on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

## `format` (type: `string`):

Return only text, image or video ads, or all formats.

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

Return only ads shown on one Google platform (same filter as the Transparency Center's Platform menu), or all platforms. Google only applies this filter to ads shown since 4 Sep 2023.

## `maxAdsPerQuery` (type: `integer`):

Stop each query after this many ads. 0 means no limit (large advertisers have tens of thousands of ads - set a limit or a maximum charge).

## `includeDetails` (type: `boolean`):

For every ad, also open its detail record: all regions it was shown in with first/last dates, EU impression ranges where Google publishes them, every creative variation's asset URL, the YouTube link for video ads, ad copy for the minority of text ads Google serves as HTML, and the advertiser's legal name, country and verification status. Charged as one extra "ad-detail" event per ad. Much slower than listing: one request per ad at a deliberately low pace.

## `onlyNewAds` (type: `boolean`):

Return (and charge) only ads this monitor has not returned before and that Google first showed since its previous run (2-day margin). The first run returns the current ads as the baseline; schedule the same task daily or weekly to get just the creatives a competitor launched in between. Skipped ads are never charged.

## `monitorName` (type: `string`):

Separate monitors keep separate memories (e.g. "brand-a-us", "competitors-de"). Stored in your named key-value store "google-ads-transparency-monitor"; delete its record to start over. Letters, digits, - \_ . only.

## `maxAdvertisersPerName` (type: `integer`):

When a query is a name, several advertisers can match (for example regional legal entities). 1 takes only the best match; raise it to include the next matches too.

## `maxRequestsPerSecond` (type: `string`):

Request pace towards Google, between 0.1 and 2. Leave empty for the default: 1 per second when only listing ads (one request returns up to 100 ads) and 0.25 per second (one request every 4 seconds) when includeDetails is on, because details need one request per ad and Google rate limits an IP address that sends many of them quickly.

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

Listing ads works without a proxy. With plain Apify Proxy (the default) the Actor connects directly first and switches to the proxy only if Google refuses the direct connection. Choose a proxy group or your own proxy URLs to always use the proxy.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "region": "anywhere",
  "format": "all",
  "platform": "all",
  "maxAdsPerQuery": 100,
  "includeDetails": false,
  "onlyNewAds": false,
  "monitorName": "default",
  "maxAdvertisersPerName": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `ads` (type: `string`):

One item per ad, with advertiser, format, dates shown, regions, preview and (optionally) per-ad details.

# 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": [
        "nike.com"
    ],
    "region": "anywhere",
    "maxAdsPerQuery": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("atkvn/google-ads-transparency-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": ["nike.com"],
    "region": "anywhere",
    "maxAdsPerQuery": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("atkvn/google-ads-transparency-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": [
    "nike.com"
  ],
  "region": "anywhere",
  "maxAdsPerQuery": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call atkvn/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,atkvn/google-ads-transparency-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/0b7Wa4hyjfOokpC3V/builds/cfYTyQlRcxP6TQyuh/openapi.json
