# Shopify App Detector: Tech Stack, Pixels & Theme (`centorprat/shopify-app-detector`) Actor

Profiles any Shopify store: every installed app with evidence (400+ known apps in 30 categories plus any app block), pixels, theme, catalog, estimated monthly app spend, missing categories and contacts. Filter to stores using or lacking an app; track installs/removals. Domains or a dataset.

- **URL**: https://apify.com/centorprat/shopify-app-detector.md
- **Developed by:** [Centor Prat](https://apify.com/centorprat) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 1,000 store detecteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Shopify App Detector: Tech Stack, Pixels & Theme

**Paste Shopify store domains (or a dataset of store URLs) and see every app each store runs**, with
the proof for each one. You also get the ad/analytics pixels, the theme, catalog stats, an **estimate of
monthly app spend**, the app categories the store is **missing**, public contacts and, if you schedule it,
**which apps were installed or removed since the last run**. It reads only Shopify's public endpoints and
the storefront: no keyword search, no paid child actor, about 3 seconds for a few stores.

### ⚡ Why it's different

- **Finds the long tail, not just the big names.** 400+ known apps in 30 categories, **plus any app that
  renders a theme app block**: Shopify marks every app block with `shopify://apps/<app-handle>`, and the
  detector reads those markers directly. Apps it has never seen are still reported by name.
- **Every app comes with evidence.** The app block, script URL, app-embed asset or widget that proves it,
  and a confidence level. No guesses from page text: content links, cookie-banner vendor lists and blog
  posts are ignored.
- **Estimated monthly app spend.** Each detected app's public plan prices, scaled by catalog size, give a
  low / likely / high range and the costliest apps. It's labelled as an estimate, not the store's bill.
- **Built for prospecting.** Missing categories ("no loyalty app", "no SMS"), pitch lines, a stack tier
  (starter / growth / scale / enterprise), enterprise signals and public emails and socials.
- **"Who uses X" from any list.** Filter any store list or dataset down to the stores that run an app
  (`requireApps: ["Klaviyo"]`), lack one (`excludeApps`) or miss a whole category (`missingCategories`).
- **Change tracking.** Pick a history store, schedule it weekly, and get back only the stores that
  installed or removed an app, changed pixels or switched theme. That's the moment a store is open to switching.
- **Instant API (Standby).** `GET https://centorprat--shopify-app-detector.apify.actor/?domain=allbirds.com`
  answers in one request, for agents and pipelines.

### 📋 What you get (per store)

| Field | What it is |
|---|---|
| `apps` | Every detected app: `name`, `category`, `confidence` (high / medium), `evidence`, `appHandle`, `known` |
| `appsDetected` | The same apps grouped by category (`reviews`, `emailSms`, `upsell`, `loyalty`, `support`, `subscriptions`, `search`, `bnpl`, `returns`, `shipping`, `analytics`, `abTesting`, `pageBuilder`, `affiliates`, `ugcVideo`, `consent`, ... 30 in all) |
| `appsCount`, `appCategories` | How many apps and which categories |
| `customApps` | Private or custom apps built for this brand (a sign of in-house dev budget) |
| `estimatedMonthlyAppSpend` | `pointUsd`, `lowUsd`, `highUsd`, `topCostApps` with each app's list-price range, and the `basis` |
| `stackTier` | starter / growth / scale / enterprise, from spend and enterprise vendors |
| `enterpriseSignals` | Enterprise vendors (Bazaarvoice, Global-e, Dynamic Yield, Signifyd...), custom apps, headless, many languages |
| `gaps`, `pitch` | Missing revenue categories with a 0-100 opportunity score and the reasons |
| `pixels` | Meta, TikTok, Google Ads, GA4, GTM, Pinterest, Snap, Microsoft UET, Reddit, X, LinkedIn, plus custom/server-side pixels |
| `theme` | Name, base theme, version, `source` (free-theme-store / paid-theme-store / custom-or-third-party), vintage flag |
| `catalog` | Products, collections, price min/median/max, % on sale, % in stock, newest product, top product types |
| Store profile | Name, myshopify domain, country/city, currency, Shop Pay, headless flag, languages |
| Contacts | Public emails and social profiles |
| `changes` | With a history store: `appsAdded`, `appsRemoved`, `pixelsAdded/Removed`, `themeChanged`, `productsDelta`, `summary` |

### 📥 Input

| Field | What it does |
|---|---|
| `domains` | Stores to profile, e.g. `["allbirds.com", "gymshark.com"]`. Storefront domains, not admin URLs. |
| `datasetId` | Any dataset whose rows contain store URLs (`url`, `website`, `domain`, `link`, or Google `organicResults`). Read-only. |
| `requireApps` | Keep only stores using any of these apps, e.g. `["Klaviyo"]`. Matches names or app handles. |
| `excludeApps` | Drop stores using any of these apps (e.g. your own app). |
| `missingCategories` | Keep only stores with no app in these categories, e.g. `["loyalty"]`. |
| `requireCategories` | Keep only stores that have these categories, e.g. `["subscriptions"]`. |
| `minEstimatedAppSpend` | Keep only stores whose estimated app spend is at least this many USD/month. |
| `storeCountries` | Keep only stores based in these countries, e.g. `["US", "CA"]` (checked first, filtered stores are free). |
| `historyStore` | A key-value store for snapshots: turns on change tracking. |
| `onlyChanged` | With a history store, return only stores whose stack changed. |
| `includeEvidence` | Attach the proof per app (default on). |
| `concurrency`, `maxItems`, `webhookUrl` | Speed, dataset cap, and a webhook that receives the results. |

**Example: find a competitor's customers in a store list**

```json
{
  "datasetId": "<your store-finder dataset>",
  "requireApps": ["Yotpo"],
  "storeCountries": ["US"]
}
```

**Example: weekly install/removal alerts on 50 stores**

```json
{
  "domains": ["allbirds.com", "gymshark.com", "deathwishcoffee.com"],
  "historyStore": "<pick a key-value store>",
  "onlyChanged": true,
  "webhookUrl": "https://hooks.zapier.com/..."
}
```

### 📤 Output (one row per store, shortened)

```json
{
  "storeName": "Death Wish Coffee",
  "url": "https://deathwishcoffee.com",
  "country": "US", "currency": "USD",
  "appsCount": 15,
  "apps": [
    {"name": "Klaviyo", "category": "emailSms", "confidence": "high", "appHandle": "klaviyo-email-marketing-sms",
     "evidence": ["app block shopify://apps/klaviyo-email-marketing-sms",
                  "https://static.klaviyo.com/onsite/js/q6rhjr/klaviyo.js?company_id=q6rhjr"]},
    {"name": "Rebuy", "category": "upsell", "confidence": "high",
     "evidence": ["app block shopify://apps/rebuy-personalization-engine"]}
  ],
  "appsDetected": {
    "reviews": ["Bazaarvoice"], "emailSms": ["Klaviyo", "Postscript"], "upsell": ["Rebuy"],
    "loyalty": ["Smile.io"], "support": ["Gorgias"], "subscriptions": ["Ordergroove"],
    "fraud": ["EasyLockdown", "MinMaxify order limits", "NoFraud (Wyllo)"],
    "channels": ["Amazon Buy Now button", "MNTN (connected TV ads)", "StackAdapt", "The Trade Desk"],
    "discounts": ["GovX ID"]
  },
  "estimatedMonthlyAppSpend": {
    "pointUsd": 2902, "lowUsd": 1660, "highUsd": 5389,
    "topCostApps": [{"app": "Bazaarvoice", "estUsdPerMonth": 1400, "listRangeUsd": [1000, 5000]},
                    {"app": "Ordergroove", "estUsdPerMonth": 750, "listRangeUsd": [500, 3000]}]
  },
  "stackTier": "scale",
  "enterpriseSignals": ["Bazaarvoice"],
  "pixels": ["googleAds", "googleAnalytics", "googleTagManager", "metaPixel", "microsoftUet", "tiktokPixel", "customPixel"],
  "theme": {"name": "deathwish-shopify-20/production", "schemaName": "Dawn", "source": "free-theme-store"},
  "sizeTier": "small", "priceMedian": 35.49,
  "topProductTypes": ["Coffee", "Apparel", "Coffee Bundle", "Accessories", "Mugs"],
  "emails": ["hey@deathwishcoffee.com"],
  "auditComplete": true
}
```

With change tracking, each row also has:

```json
"changes": {"appsAdded": ["Skio"], "appsRemoved": ["Recharge"], "themeChanged": {"from": "Old Theme", "to": "Production"},
            "productsDelta": 7, "hasChanges": true, "summary": "installed Skio; removed Recharge; theme Old Theme -> Production"}
```

### 💰 Pricing (pay-per-event)

- **Store detected: $0.004** per verified Shopify store fully profiled. That's $4 per 1,000 stores.
- Free: non-Shopify domains, stores whose pages can't be read, and stores dropped by `storeCountries`.
- App, category and spend filters run after the profile, so every profiled store is billed even if a filter
  leaves it out. Pre-filter big lists by country to save.

### 💡 Use cases

- **App vendors: displacement lists.** Feed any store list, keep the stores on a competitor's app, then
  watch for removals.
- **Agencies: audit before the pitch.** Full stack, estimated spend, missing categories and contacts in one row.
- **Sales teams: qualify by budget.** `minEstimatedAppSpend` plus `stackTier` separate hobby stores from brands that pay for software.
- **Investors and analysts: market sizing.** Install footprints per category across a market.
- **Competitive intelligence.** Know the day a rival adds Recharge, drops Klaviyo or switches theme.
- **Enrichment.** Profile the output of any store-finder, ad-library or Google Search run (pass its `datasetId`).

### 🚀 Ready-made tasks (one click)

- [What Apps Does a Shopify Store Use?](https://apify.com/centorprat/shopify-app-detector/examples/shopify-app-detector-store): paste domains, get every app, pixel, theme and catalog stat per store.
- [Shopify Tech Stack Lookup (Bulk Domains)](https://apify.com/centorprat/shopify-app-detector/examples/shopify-tech-stack-lookup): bulk tech-stack profile for a list of stores or a dataset of URLs.
- [Shopify Pixel & Theme Detector](https://apify.com/centorprat/shopify-app-detector/examples/shopify-pixel-theme-detector): which pixels (Meta, TikTok, Google Ads, GA4) and theme each store runs.
- [Find Shopify Stores Using Klaviyo](https://apify.com/centorprat/shopify-app-detector/examples/find-shopify-stores-using-klaviyo): keep only the stores in your list that run Klaviyo.
- [Shopify App Spend Estimator](https://apify.com/centorprat/shopify-app-detector/examples/shopify-app-spend-estimator): estimated monthly app spend and the costliest apps per store.
- [Shopify Stores Without a Loyalty App](https://apify.com/centorprat/shopify-app-detector/examples/shopify-stores-without-loyalty-app): stores that have no loyalty or referral program yet.

### 🔌 API, Standby and agents

**Instant lookup (Standby):** one HTTP request, JSON back, $0.004 per store.

```bash
curl "https://centorprat--shopify-app-detector.apify.actor/?domain=allbirds.com&token=<YOUR_APIFY_TOKEN>"
curl "https://centorprat--shopify-app-detector.apify.actor/?domains=gymshark.com,allbirds.com&requireApps=Klaviyo&includeEvidence=false&token=<YOUR_APIFY_TOKEN>"
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("centorprat/shopify-app-detector").call(run_input={"domains": ["allbirds.com", "gymshark.com"]})
for store in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(store["storeName"], store["appsCount"], store["estimatedMonthlyAppSpend"]["pointUsd"])
```

**JavaScript**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('centorprat/shopify-app-detector').call({ domains: ['allbirds.com'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**MCP (Claude, Cursor, any MCP client)**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=actors,docs,centorprat/shopify-app-detector"
    }
  }
}
```

**Claude Code:** `claude mcp add --transport http apify "https://mcp.apify.com/?tools=actors,docs,centorprat/shopify-app-detector" --header "Authorization: Bearer <YOUR_APIFY_TOKEN>"`

### ❓ FAQ

**How does it know an app is installed?** From what the storefront actually loads: Shopify's own
`shopify://apps/<handle>` app-block markers, the app's script and asset URLs (including ScriptTag loaders and
app-embed extension assets), the app's widget containers in the theme, and Shopify's web-pixel configuration.
Every app in the output lists the evidence.

**Can it see apps that never touch the storefront?** No. Back-office apps (inventory, accounting, ERP) leave
no public trace. It detects what a shopper's browser loads, which covers reviews, email/SMS, upsell,
loyalty, chat, subscriptions, search, returns, tracking, analytics, A/B testing and the rest.

**How accurate is the spend estimate?** It's a planning number, not a bill. Each app's public plan-price
range is scaled by catalog size; usage fees, per-order fees and negotiated contracts aren't included. Use it
to rank and segment stores, not to quote a price.

**What does "unknown" mean on an app?** The store runs an app with a theme app block that isn't in our
database yet. You still get its name (from the app handle) and a guessed category.

**How does change tracking work?** The first run with a history store saves a snapshot per store. Later runs
compare against it and report apps installed or removed, pixel and theme changes, and catalog growth, then save
the new snapshot. Schedule it weekly.

**Is it billed when a filter drops a store?** Yes. The store was fully profiled. Country filtering
happens before profiling, so it's free.

**Headless stores?** Flagged with `isHeadless: true`. Their custom front-ends often hide apps, so the list
can be partial.

**How fast is it?** About 2-4 seconds per store, 8 stores in parallel by default (up to 16).

**Is it legal?** It reads public pages and Shopify's public `/meta.json` and `/products.json`, like a
browser. No login, no private data, no checkout.

**Output formats?** JSON, CSV, Excel, XML or HTML from the dataset, or straight from the Standby endpoint.

### 📜 Data & attribution

Reads only publicly available Shopify endpoints and storefronts. No login, no private data. App names are
trademarks of their owners; prices are public list prices used for estimates only.

### 🔗 Related actors

- [Local Business Software Detector: POS, Booking & Ordering](https://apify.com/centorprat/local-business-software-detector): which POS, ordering, booking, practice or field-service software a local business runs, with gaps and contacts.
- [SaaS Stack & Email Provider Detector: M365, Okta, HubSpot](https://apify.com/centorprat/saas-stack-email-provider-detector): a company's email provider, security gateway, SSO and verified SaaS from its domain or a work email.
- [WordPress Plugin Detector: Plugins, Versions & WooCommerce](https://apify.com/centorprat/wordpress-plugin-detector): every plugin a WordPress site runs, checked against wordpress.org (outdated, removed for security), plus WooCommerce facts.
- [Shopify Dropshipping & Store Trust Checker](https://apify.com/centorprat/shopify-dropshipping-checker): check any Shopify store for dropshipping signals (AliExpress images, markups, new catalogues) and a store-trust band — signals, not accusations.
- [Shopify Store Leads + App Audit](https://apify.com/centorprat/shopify-store-leads-app-audit): find Shopify stores by niche keyword, scored for the apps they are missing, with emails and socials.
- [Google Maps Leads + Website Audit for Agencies](https://apify.com/centorprat/google-maps-leads-website-audit): local businesses from Google Maps audited for website, Google profile, reviews, booking and tracking gaps.
- [Domain Lookup API - DNS, MX, SPF, Tech & Contact Emails](https://apify.com/centorprat/domain-lookup-dns-mx-email): DNS + live homepage → IPs, MX/SPF, tech, socials and public contacts per domain.
- [Wikipedia & Wikidata API - Entity Facts, Summary & Pageviews](https://apify.com/centorprat/wikipedia-wikidata-api): Wikipedia + Wikidata + pageviews → one structured brief per company, person or place.
- [FEMA Flood Zone & Property Risk API - Zillow/Redfin Enricher](https://apify.com/centorprat/fema-flood-zone-property-risk): FEMA flood zone + 18-hazard risk index + neighborhood demographics per US address.
- [Country Economic Data API - World Bank GDP, FX & Holidays](https://apify.com/centorprat/world-bank-country-economic-data): World Bank + FX + public holidays → one market brief per country.
- [Weather, Air Quality & Earthquake Risk API by Location](https://apify.com/centorprat/weather-air-quality-earthquake-api): live weather + air quality + earthquakes → one verdict per point.
- [Aircraft Tracker API (ADS-B) - Approach & Military Alerts](https://apify.com/centorprat/aircraft-tracker-adsb): aircraft approaching a point with CPA/ETA + military/unidentified flags.
- [NARA Catalog Extractor](https://apify.com/centorprat/nara-catalog-extractor): US National Archives catalog search → digital-object download URLs + metadata.

# Actor input Schema

## `domains` (type: `array`):

The Shopify stores to profile, e.g. \["allbirds.com", "gymshark.com"]. Storefront domains, not myshopify admin URLs. Non-Shopify sites are skipped for free.

## `datasetId` (type: `string`):

Pick (or paste the ID of) any dataset whose rows contain store URLs or domains (url, website, domain, link fields, or Google organicResults). Read-only. Use this to profile the output of a store finder, ad-library or Google Search run, then keep only the stores that use (or lack) an app with the filters below.

## `requireApps` (type: `array`):

Return only stores running at least one of these apps, e.g. \["Klaviyo"] or \["Recharge", "Skio"]. Matches app names or Shopify app handles, case-insensitive. Use it to build a list of a competitor's customers from any store list.

## `excludeApps` (type: `array`):

Leave out stores running any of these apps, e.g. your own app's name so you only see prospects.

## `missingCategories` (type: `array`):

Return only stores with no app in these categories, e.g. \["loyalty"] or \["reviews", "emailSms"]. Category keys: reviews, emailSms, upsell, loyalty, support, subscriptions, search, bnpl, returns, shipping, analytics, abTesting, personalization, pageBuilder, consent, accessibility, affiliates, ugcVideo, productOptions, preorder, wishlist, giftCards, localization, seo, fraud, forms, quizzes, channels, b2b, discounts, storefrontUx.

## `requireCategories` (type: `array`):

Return only stores with at least one app in each of these categories, e.g. \["subscriptions"]. Same keys as above.

## `minEstimatedAppSpend` (type: `integer`):

Return only stores whose ESTIMATED monthly app spend is at least this much, e.g. 500 for stores that clearly pay for software. The estimate comes from public plan prices x catalog size; it is not the store's actual bill.

## `storeCountries` (type: `array`):

Keep only stores based in these countries (two-letter codes from the store's Shopify settings), e.g. \["US", "CA"]. Checked before the full profile, so filtered-out stores are free.

## `historyStore` (type: `string`):

Pick (or create) a key-value store to keep a snapshot of each store's stack. Every later run reports what changed since the previous one: apps installed and removed, pixels added and removed, theme switches, catalog growth. Schedule the Actor weekly on your competitor or prospect list.

## `onlyChanged` (type: `boolean`):

With a history store: return only stores where an app, pixel or theme changed since the last run (plus stores seen for the first time). Ideal for scheduled alert runs with a webhook.

## `includeEvidence` (type: `boolean`):

Attach the proof for each detected app (the app block, script URL or widget that revealed it). Turn off for smaller rows.

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

Safety cap when reading a dataset.

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

How many stores are profiled at once.

## `webhookUrl` (type: `string`):

If set, the results are POSTed here as JSON (Zapier / Make / n8n / your CRM). With change tracking, the payload starts with a short list of what changed per store.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com",
    "deathwishcoffee.com",
    "drinkolipop.com"
  ],
  "onlyChanged": false,
  "includeEvidence": true,
  "maxItems": 2000,
  "concurrency": 8
}
```

# Actor output Schema

## `stores` (type: `string`):

One row per verified Shopify store: every detected app (name, category, confidence, evidence, app handle) and the same grouped by category, custom/private apps, estimated monthly app spend with the costliest apps, stack tier, enterprise signals, missing categories (gaps) and pitch lines, ad/analytics pixels, theme (free / paid / custom), catalog stats, contacts, and - with a history store - what changed since the last run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "allbirds.com",
        "deathwishcoffee.com",
        "drinkolipop.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("centorprat/shopify-app-detector").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 = { "domains": [
        "allbirds.com",
        "deathwishcoffee.com",
        "drinkolipop.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("centorprat/shopify-app-detector").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 '{
  "domains": [
    "allbirds.com",
    "deathwishcoffee.com",
    "drinkolipop.com"
  ]
}' |
apify call centorprat/shopify-app-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,centorprat/shopify-app-detector"
        }
    }
}
```

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/zQm88OzWj968iJHUu/builds/R6BbnSj8bHcqhJPeY/openapi.json