# Google Ads Transparency Scraper - Decoded Creatives (`automation_craft/google-ads-transparency-scraper`) Actor

Pull every ad an advertiser runs from the Google Ads Transparency Center by name, domain, AR id or pasted URL, no login or API key. Search, YouTube, Shopping, Maps and Play ads with decoded headline, description, image, YouTube id, dates, EU impression bands and political spend. Pay per creative.

- **URL**: https://apify.com/automation\_craft/google-ads-transparency-scraper.md
- **Developed by:** [Automation Craft](https://apify.com/automation_craft) (community)
- **Categories:** Marketing, Lead generation, Social media
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.32 / 1,000 creatives

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

### Google Ads Transparency Scraper - Decoded Creatives

**Scrape the Google Ads Transparency Center** for any advertiser and get every creative back with the copy decoded: headline, description, call to action, display and landing URLs, image, YouTube video id, first and last shown dates, days served, served regions, EU impression bands and political spend. No login, no cookies, no API key. Pay per creative; creatives your memory already knows are free.

Google publishes the ads of every verified advertiser at adstransparency.google.com, but the site is built for browsing one advertiser at a time and hides the ad copy inside a rendered preview. This Actor calls the same endpoints the site uses, pages through an advertiser's creatives at 100 per request, decodes the preview payloads and returns flat rows you can filter, schedule and export.

### Quick start

1. In **Advertisers**, enter a website domain (`nike.com`), an advertiser name, an AR id, or paste a Transparency Center URL. One line per advertiser.
2. Pick a **Region** (or leave Anywhere), and any **Platforms**, **Formats** or date window. Filter by platform (Google Search, YouTube, Shopping, Maps, Play) and format (text, image, video), or leave both empty for every creative.
3. Set **Max creatives per advertiser** and **Max creatives per run**.
4. Keep **Decode creatives** on to get the copy, media and EU data; turn it off for metadata and preview URLs only.
5. Run. Rows land in the dataset (JSON, CSV, Excel, API). For a scheduled competitor watch, set a **Memory name** and every later run returns only new creatives.

### What you get

One row per creative. The columns in the table view are the ones most people use; the JSON row carries everything.

Measured on 180 live creatives (2026-09-22); percentage of rows where the field is filled.

| field | text ads | image ads | video ads |
|---|---|---|---|
| `headline` | 73% | 0% | 43% |
| `description` | 73% | 0% | 38% |
| `callToAction` | 0% | 5% | 43% |
| `displayUrl` | 73% | 0% | 37% |
| `landingUrl` | 0% | 27% | 0% |
| `businessName` | 7% | 0% | 37% |
| `storeLocations` | 62% | 0% | 0% |
| `productTitle` | 0% | 27% | 0% |
| `merchantName` | 0% | 27% | 0% |
| `imageUrl` | 72% | 92% | 50% |
| `youtubeVideoId` | 0% | 0% | 52% |
| `videoUrls` | 0% | 0% | 18% |
| `appName` | 0% | 0% | 7% |
| `firstShown` | 100% | 100% | 100% |
| `lastShown` | 100% | 100% | 100% |
| `daysServed` | 100% | 100% | 100% |
| `regionStats` | 100% | 100% | 100% |
| `payerName` | 47% | 70% | 57% |
| `category` | 0% | 23% | 0% |

| field | meaning |
|---|---|
| `advertiserName`, `advertiserId`, `advertiserRegion`, `advertiserVerified`, `payerName` | the advertiser as Google verified it, its AR id, home region, verification flag and the legal payer name from the creative detail |
| `creativeId`, `format`, `transparencyUrl`, `previewUrl` | Google's CR id, TEXT / IMAGE / VIDEO, the link to the creative in the Transparency Center, the raw preview URL |
| `headline`, `description`, `callToAction`, `displayUrl`, `businessName`, `businessCategory`, `storeLocations`, `phone` | decoded search, local and companion copy; location extensions with store name, address and city |
| `ocrStatus`, `ocrConfidence`, `ocrText`, `ocrLanguage`, `sitelinks` | with OCR on: how the render was read, the recognition confidence, the full recognised text, the language pack used, the sitelinks visible in the render |
| `productTitle`, `merchantName`, `offerId`, `landingUrl`, `cssPartner` | Shopping creatives: product, merchant, GTIN or offer id, product landing URL, comparison shopping partner |
| `appName`, `appId`, `appIconUrl`, `developerName` | App install creatives (Google Play) |
| `imageUrl`, `imageUrls`, `width`, `height` | the creative image (Google's archived render for text ads, the display image otherwise) and its size |
| `youtubeVideoId`, `youtubeUrl`, `videoUrls` | video creatives: YouTube id and watch URL where the rendering embeds YouTube; signed playback URLs (they expire within hours, fetch what you keep) |
| `firstShown`, `lastShown`, `daysServed`, `servedCountries`, `matchedDomain` | dates as ISO timestamps, number of days served, ISO country codes the creative was shown in |
| `regionStats`, `eeaImpressions`, `usImpressions` | EU transparency: per region impression bands with per surface breakdown (Search, YouTube, Shopping, Maps, Play) and dates; aggregate EEA and US bands |
| `impressionsLower`, `impressionsUpper`, `spendLower`, `spendUpper`, `spendCurrency`, `targeting`, `politicalRegions` | political ads: impression and spend ranges, age, gender and location targeting, audience selection categories |
| `category`, `vertical`, `containsSyntheticMedia` | topic provided by the advertiser, vertical, Google's synthetic media disclosure |
| `isNew`, `memoryStatus`, `decodeStatus`, `decodeSources`, `query`, `scrapedAt` | provenance: memory result, how the row was decoded (detail, overlay, bundle), which input line produced it |

A `run-summary` row closes every dataset: per advertiser requested, found (Google's size band), delivered, known skipped, pages fetched and stop reason; decode statistics; request counts and proxy mode; charges attempted and confirmed; memory state.

Sample creative row:

```json
{
  "type": "creative",
  "advertiserName": "株式会社ナイキジャパン",
  "advertiserId": "AR01437837420136497153",
  "advertiserRegion": null,
  "advertiserVerified": true,
  "payerName": "株式会社ナイキジャパン",
  "creativeId": "CR15429817122099822593",
  "format": "TEXT",
  "headline": "【ナイキ公式】オンラインストア",
  "description": "季節のオススメやベストセラー、クリアランスが勢揃い。ジブンだけのカスタマイズも。",
  "displayUrl": "nike.com",
  "businessName": "ナイキジャパン",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/13803053261096263349",
  "imageUrls": [
    "https://tpc.googlesyndication.com/archive/simgad/13803053261096263349",
    "https://tpc.googlesyndication.com/archive/simgad/1021467459010002479",
    "https://tpc.googlesyndication.com/archive/simgad/3595071776370173829"
  ],
  "storeLocations": [
    {
      "name": "Nike Factory Store",
      "address": "土岐ヶ丘１丁目２, 土岐プレミアムアウトレット 210",
      "city": "土岐市",
      "region": "岐阜県",
      "postalCode": "509-5127",
      "country": "JP"
    }
  ],
  "width": 380,
  "height": 400,
  "firstShown": "2025-08-04T07:03:47.000Z",
  "lastShown": "2026-09-22T14:16:58.000Z",
  "daysServed": 415,
  "matchedDomain": "nike.com",
  "categoryId": 10021,
  "impressionsLower": null,
  "impressionsUpper": null,
  "spendLower": null,
  "spendUpper": null,
  "spendCurrency": null,
  "regionStats": [
    {
      "region": "KR",
      "impressionsLower": null,
      "impressionsUpper": null,
      "firstShown": null,
      "lastShown": "2026-09-17",
      "dataAvailableFrom": null,
      "surfaces": []
    },
    {
      "region": "JP",
      "impressionsLower": null,
      "impressionsUpper": null,
      "firstShown": null,
      "lastShown": "2026-09-22",
      "dataAvailableFrom": null,
      "surfaces": []
    }
  ],
  "targeting": {
    "age": null,
    "gender": null,
    "geoCriteriaIds": null,
    "audienceSelection": {
      "demographics": {
        "included": true,
        "excluded": false
      },
      "geographicLocations": {
        "included": true,
        "excluded": false
      },
      "contextualSignals": {
        "included": true,
        "excluded": true
      }
    }
  },
  "politicalRegions": null,
  "reportedByUser": false,
  "previewUrl": "https://tpc.googlesyndication.com/archive/simgad/13803053261096263349",
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR01437837420136497153/creative/CR15429817122099822593?region=anywhere",
  "variantCount": 4,
  "creativeType": 102,
  "decodeStatus": "decoded",
  "decodeSources": [
    "detail",
    "bundle"
  ],
  "isNew": true,
  "memoryStatus": "NO_MEMORY",
  "query": {
    "input": "nike.com",
    "kind": "domain",
    "value": "nike.com",
    "region": "ANYWHERE",
    "format": "all"
  },
  "scrapedAt": "2026-09-22T14:52:07.041Z"
}
```

### How much does it cost to scrape the Google Ads Transparency Center?

Pay per event, nothing per month. The Store card shows the same prices per 1,000 events.

| event | price | when it is charged |
|---|---|---|
| Creative | $0.40 per 1,000 | one creative row delivered (Silver 10 percent off, Gold 20 percent off) |
| Creative decoded | $0.30 per 1,000 | the detail and rendering decoded on top of a creative row, only when the decode returned data (same tiers) |
| OCR read | $0.50 per 1,000 | with "Read image-only text ads (OCR)": the copy read out of a text ad Google publishes only as an image, only when a headline was recognised (same tiers) |
| Actor start | $2.50 per 1,000 runs (0.25 cents per run) | once per run, so a monitoring run that finds nothing new costs a fraction of a cent |

Worked example: 1,000 decoded creatives of one advertiser cost $0.70 plus one start fee. A weekly watch of five competitors that finds 40 new creatives costs 40 x ($0.40 + $0.30) / 1,000 plus the start fee, about 4 cents. Known creatives, filtered rows, run summaries, status rows and failed runs are free.

### Input

| field | notes |
|---|---|
| `advertisers` | domains, names, AR ids or pasted `adstransparency.google.com` URLs (advertiser page, `?domain=` search, or one creative). Names are resolved through Google's own suggestions; a domain is the most exact key. |
| `region` | one of 244 regions or `ANYWHERE` |
| `platforms` | `search`, `youtube`, `shopping`, `maps`, `play` (empty = all) |
| `formats` | `text`, `image`, `video` (empty = all) |
| `lastShownAfter`, `lastShownBefore` | `YYYY-MM-DD`, applied by Google |
| `topic` | `all` or `political` |
| `sort` | `lastShown` (default) or `impressions` |
| `maxCreativesPerAdvertiser`, `maxTotal` | caps; the run summary says why each advertiser stopped |
| `decodeCreatives` | on in the Console by default, off for API callers who do not send it |
| `ocrImageOnlyText` | read image-only text ads with the built-in OCR engine (needs `decodeCreatives` and a run memory of 512 MB or more); off by default |
| `memoryName`, `emitKnown`, `resetMemory` | cross-run memory |
| `concurrency` | advertisers paged in parallel (1 to 8) |
| `proxyConfiguration` | Apify datacenter by default with automatic residential fallback for the small RPC calls |

API example:

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~google-ads-transparency-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"advertisers": ["nike.com"], "region": "US", "maxCreativesPerAdvertiser": 200, "decodeCreatives": true}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation_craft/google-ads-transparency-scraper').call({ advertisers: ['nike.com'], platforms: ['youtube'], formats: ['video'], maxCreativesPerAdvertiser: 100, decodeCreatives: true, memoryName: 'weekly-watch' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation_craft/google-ads-transparency-scraper").call(run_input={"advertisers": ["nike.com"], "lastShownAfter": "2026-09-01", "decodeCreatives": True})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### What this Actor does NOT do

- Keyword search across commercial ads: the Transparency Center only searches ad text within political ads. Keywords are resolved to advertisers (what the website does).
- Read the copy out of image-only text ads unless you turn on "Read image-only text ads (OCR)": without it those rows carry the image URL and `decodeStatus: image_only`. With it, about 8 percent of renders still come back without a headline (a product photo across the text, a truncated render, Google's placeholder templates) and are not billed.
- Download media files: it returns image and video URLs; the signed video playback URLs expire within hours.
- Exact match counts for commercial searches: Google gives a size band (`foundLower`, `foundUpper` in the run summary); political searches get exact counts.
- Show impressions or spend for commercial ads outside the EU: Google publishes none. EU rows carry `regionStats`; political rows carry spend and impression ranges.
- Reach ads older than what Google keeps for an advertiser.

### FAQ

#### Does the Google Ads Transparency Center have an API?

No public API exists. This Actor reads the same JSON endpoints the Transparency Center website calls, with no login, no cookies and no key, and bills per creative delivered. The BigQuery datasets Google publishes cover only political ads and, since 2025, EU ads.

#### How do I see all the ads a competitor is running on Google?

Put the competitor's website domain (the most exact match) or name in "Advertisers", leave the filters empty and set your caps. Every creative comes back with format, first and last shown dates, days served and, with "Decode creatives" on, the headline, description, image, YouTube id and EU impression bands.

#### Why do some text ads come back with an image but no headline?

Google publishes many text ads only as a rendered image (the "simgad" PNG you see in the Transparency Center). The Actor delivers that image URL and marks the row `decodeStatus: image_only`. Where Google also serves the rendering script, the copy is decoded and the row says `decoded`.

#### Can I filter by region, platform, format and date?

Yes, and every filter is applied by Google itself: region (244 regions), platforms (Search, YouTube, Shopping, Maps, Play), formats (text, image, video) and a shown-between date window. The run summary reports the size band Google gave for each query.

#### How do I monitor new Google ads automatically?

Set a "Memory name" and schedule the run. Creatives delivered under that name are remembered; every later run returns only the creatives you have not received yet, and known creatives are never charged again.

#### How does the OCR for image-only text ads work and how accurate is it?

Google publishes about a quarter of text ads only as a rendered PNG. With "Read image-only text ads (OCR)" on, the Actor runs the open source Tesseract engine inside the run (no key, no third party) on Google's own clean render, masks the logo and product photo, and recovers headline, description, display URL and sitelinks from the line layout. Measured on 66 live renders where Google also exposed the real copy: the headline was recovered on 92 percent of Latin-script renders; Japanese reads at about 90 percent per character. Every OCR row carries `ocrConfidence`, and a render with no real copy (Google's placeholder templates) is never billed.

#### Why does this Actor run with limited permissions?

Least privilege: it only needs its own dataset, its own key-value store and the Apify proxy. The cross-run memory is a named key-value store the Actor creates itself, so nothing outside its own storages is touched.

### More data tools by Automation Craft

- [Google Ads Library Scraper - Competitor Ads, No Login](https://apify.com/automation_craft/google-ads-library-scraper)
- [YouTube Ads Scraper - Video Ads by Advertiser](https://apify.com/automation_craft/youtube-ads-scraper)
- [Facebook Ads Library Scraper - Page Ads, No Login](https://apify.com/automation_craft/facebook-ads-library-scraper)
- [Meta Ad Library Scraper - All Placements, Filters](https://apify.com/automation_craft/meta-ads-library-scraper)
- [Instagram Ads Library Scraper - Creatives, Video](https://apify.com/automation_craft/instagram-ads-library-scraper)
- [LinkedIn Ad Library Scraper](https://apify.com/automation_craft/linkedin-ad-library-scraper)
- [Google Trends Scraper](https://apify.com/automation_craft/google-trends-scraper)
- [Google News Scraper](https://apify.com/automation_craft/google-news-scraper)

### Changelog

- 0.2.0 (2026-09-23): OCR for image-only text ads (opt in, priced per read).
- 0.1.0 (2026-09-22): first release. Advertiser resolution by name, domain, id or URL; region, platform, format, date and topic filters applied by Google; decode of search, local, shopping, app and video creatives; EU impression bands; political spend; cross-run memory; per run ledger.

# Actor input Schema

## `advertisers` (type: `array`):

One entry per advertiser. Accepts a website domain ("nike.com", the most exact), an advertiser name ("Nike, Inc.", resolved through the Transparency Center's own suggestions), an AR id ("AR16735076323512287233") or a pasted adstransparency.google.com URL (advertiser page, ?domain= search, or a single creative link). Case, spaces, http and www do not matter.

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

Only creatives shown in this region (the Transparency Center "region" filter). "Anywhere" searches every region. API callers send the upper case ISO code (US, GB, DE) or ANYWHERE.

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

Where the ad ran: Google Search, YouTube, Shopping, Maps or Google Play. Leave empty for every platform.

## `formats` (type: `array`):

Text, image or video creatives. Leave empty for all three.

## `lastShownAfter` (type: `string`):

Only creatives that were shown on or after this date (the Transparency Center date filter). Leave empty for no lower bound.

## `lastShownBefore` (type: `string`):

Only creatives that were shown on or before this date. Leave empty for no upper bound.

## `topic` (type: `string`):

All ads, or only political ads (Google's political report: exact match counts, spend and impression ranges, audience selection). A political pull without an advertiser needs a region.

## `sort` (type: `string`):

Order in which Google returns creatives, which decides which ones fit under your cap: most recently shown first (default) or highest impressions first.

## `maxCreativesPerAdvertiser` (type: `integer`):

Stop each advertiser after this many delivered creatives. Google returns 100 per page; large advertisers hold tens of thousands.

## `maxTotal` (type: `integer`):

Hard cap on delivered creatives for the whole run, across all advertisers.

## `decodeCreatives` (type: `boolean`):

Fetch each creative's detail and rendering and decode it: headline, description, call to action, display and landing URLs, product and merchant, YouTube video id and playback URLs, store locations, served countries, EU impression bands per region and surface, topic and payer name. $0.30 per 1,000, charged only when the decode returned data. Off = metadata, preview and image URLs only.

## `ocrImageOnlyText` (type: `boolean`):

About a quarter of text ads are published by Google only as a rendered image. With this on (and "Decode creatives" on), the Actor reads the headline, description, display URL and sitelinks out of that image with an open source OCR engine running inside the Actor, no key, no third party. $0.50 per 1,000, charged only when a headline was read; the row carries the recognised text and a confidence score. Measured on 66 live renders: the headline is recovered on 92 percent of Latin-script renders, Japanese at about 90 percent per character. Needs a run memory of 512 MB or more (set it in the run options); with less, rows are delivered without OCR and nothing is charged for it.

## `memoryName` (type: `string`):

Give a name and the Actor remembers every creative it delivered under it. Later runs with the same name return only creatives you have not received yet; known creatives are skipped and never charged again. Ideal for a scheduled competitor watch.

## `emitKnown` (type: `boolean`):

With a memory name: also deliver creatives the memory already knows, marked isNew: false and never charged.

## `resetMemory` (type: `boolean`):

Forget every creative remembered under the memory name before this run.

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

How many advertisers are paged at the same time. Each worker holds its own rotating proxy session.

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

Apify datacenter proxy by default (near free); the Actor rotates sessions itself and falls back to Apify residential for the small RPC calls when Google refuses the datacenter pool. Selecting RESIDENTIAL here routes every call residential.

## Actor input object example

```json
{
  "advertisers": [
    "nike.com"
  ],
  "region": "ANYWHERE",
  "topic": "all",
  "sort": "lastShown",
  "maxCreativesPerAdvertiser": 20,
  "maxTotal": 100,
  "decodeCreatives": true,
  "ocrImageOnlyText": false,
  "emitKnown": false,
  "resetMemory": false,
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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 = {
    "advertisers": [
        "nike.com"
    ],
    "maxCreativesPerAdvertiser": 20,
    "maxTotal": 100,
    "decodeCreatives": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/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 = {
    "advertisers": ["nike.com"],
    "maxCreativesPerAdvertiser": 20,
    "maxTotal": 100,
    "decodeCreatives": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation_craft/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/dZYY6Gu5JGjljghXb/builds/YtFcgJ5OB15vgES8A/openapi.json