# 1688 Image Search Scraper — Find Suppliers by Photo (`crawleast/1688-image-search-scraper`) Actor

Find the factory behind any product photo: reverse image search on 1688.com with supplier prices, MOQ ladders, landed cost and dropship scores — pay only for successful matches.

- **URL**: https://apify.com/crawleast/1688-image-search-scraper.md
- **Developed by:** [Kyle Wang](https://apify.com/crawleast) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 image searches

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 1688 Image Search Scraper — Find Suppliers by Photo

> **Screenshot → factory price → landed cost in one call.**
> Upload a product photo, get up to **20 visually similar 1688.com listings per image** with factory prices, MOQ and supplier trust signals — **$0.005 per successful search + a $0.01 run base fee charged only when matches are delivered**, no start fee, no login, no need to read Chinese (titles arrive machine-translated to English, originals preserved). Switch on `enrichDetails` and every delivered match arrives with SKUs, an English title, a dropship-ready score and an estimated landed cost in USD.

### ✅ What you get / ❌ what you avoid

| ✅ You get | ❌ What others charge you for (or fail at) |
| --- | --- |
| Pay-per-success: only images returning ≥1 match are billed ($0.005) | **devcake-style per-row billing from $3.00/1k rows** (as of Aug 2026) — you pay for every row, even useless ones |
| Full detail enrichment at **$0.003 per delivered detail** — failed details are never charged | Hidden start fees (`apify-actor-start`) on top of item pricing |
| Decision-grade output: landed cost, dropship score, compliance hints | Field-stuffed dumps you still have to analyze by hand |
| **No 1688 account, no login, no cookies to babysit** | Solutions that break when your session expires |
| Failed / empty / truncated work is **never charged**; hard budget cap per run | **dev00's reverse-image-search API shows ~80–85% run success rate per Apify Store stats** (as of Aug 2026) — you gamble on every call |
| Automatic compensation retry for transient detail failures (see Limits) | Silent partial deliveries you discover days later |

### Who it's for

- 📸 **Dropshippers & TikTok Shop sellers** — screenshot a trending product, find the factory behind it and its real price in seconds
- 🛒 **Amazon/eBay resellers** — compare 20 suppliers per photo, see MOQ ladders and landed cost before you buy samples
- 🕵️ **Sourcing agents** — turn client photos into supplier shortlists with trust signals (years on 1688, Super Factory badge, repeat-buyer rate)
- 🤖 **AI agents & pipelines** — clean JSON in/out, API-first, built to be called by your automation (see [Copy to your AI assistant](#copy-to-your-ai-assistant))
- 🔍 **Price intelligence** — track factory prices of products you already sell via `offerIds` detail-only mode

### Trust at a glance

| What we commit to | How it works here |
| --- | --- |
| Pay only for delivered results | Zero-match runs cost **$0.00** — failed downloads, risk-control blocks and undelivered details are never charged |
| No hidden usage fees | Pure pay-per-event pricing; proxy and platform compute costs are included, never passed through |
| Honest degradation | Every run's SUMMARY discloses per-image status, the billing ledger and the reason whenever anything short-falls |
| Subscriber discounts | Up to **−10%** on image-search events (SILVER −4%, GOLD and above −10%) |
| MCP / agentic-payment ready | Input, dataset, key-value-store and output schemas are all declared — machines can validate the contract before calling |
| Issues answered fast | Open an Issue instead of guessing — our response time is public on the developer profile |
| Live reliability stats | Success rate and run volume are shown live on this Store page — judge from real data, not claims |

### One-click examples

Skip the input form — these public tasks run proven configurations in one click:

- **[Quick Start — photo to suppliers](https://apify.com/crawleast/1688-image-search-scraper/1688-image-search-quick-start)** — one photo, up to 20 matching listings with factory prices
- **[Quick Start with full details & landed cost](https://apify.com/crawleast/1688-image-search-scraper/1688-image-search-quick-start-full-details)** — matches upgraded to SKUs, dropship score and USD landed cost
- **[Offer ID quick lookup](https://apify.com/crawleast/1688-image-search-scraper/1688-offer-quick-lookup)** — full supplier detail for known 1688 product IDs, no image needed

### Sample output

> **Reading the dataset:** with `enrichDetails: true`, runs write progressive snapshots into the append-only dataset as details arrive — **take the LAST `imageResult` block per query image** (it is the most enriched one). Card-only runs flush once per image.

One dataset row per query image (`type: "imageResult"`), matches embedded in `results`. With `enrichDetails: true`, each delivered match is upgraded from a search card to a full detail object like this (real output, arrays trimmed):

```json
{
  "offerId": "692120494348",
  "detailLevel": true,
  "titleCn": "厂家批发 平板电脑保护套肩带 相机背带 音响背带",
  "titleEn": "Manufacturer Wholesale Tablet Case Shoulder Strap Camera Strap Speaker Strap",
  "detailUrl": "https://detail.1688.com/offer/692120494348.html",
  "price": { "min": 1.9, "max": 2.2, "currency": "CNY", "unit": "piece" },
  "moq": 1000,
  "quantityPrices": [
    { "price": 2.2, "minQuantity": 1000 },
    { "price": 2.0, "minQuantity": 5000 },
    { "price": 1.9, "minQuantity": 10000 }
  ],
  "stock": { "total": 1325250 },
  "city": "广东省深圳市",
  "supplier": {
    "companyName": "深圳市光明区兴凯鸿纺织商行",
    "sellerType": "superFactory",
    "isSuperFactory": true,
    "scores": { "service": "4.5", "repeatRate3m": "29.41%" }
  },
  "supplierRepeatRate3m": 0.2941,
  "weightKg": null,
  "dropshipReadyScore": 44,
  "dropshipGrade": "F",
  "dataQuality": "minimal",
  "estLandedCostUsd": {
    "unitCostUSD": 0.26,
    "internationalShippingUSD": 2.72,
    "totalLandedCostUSD": 3.35,
    "suggestedRetailPriceUSD": 10.05,
    "estimatedMarginPercent": 66.7
  },
  "compliance": {
    "targetMarket": "US",
    "suggestedCertifications": ["CPSC compliance"],
    "riskFlags": []
  },
  "scrapedAt": "2026-08-23T17:23:17.977Z"
}
```

Without enrichment you still get a rich **search card** per match: `offerId`, `similarityRank`, `title` (Chinese), `priceYuan`, `consignPriceYuan` (dropship price), `moq`, `bookedCount` (demand), `supplier` (years on platform, factory flags, composite score), `imageUrl`, `detailUrl`.

Every field is documented in the **dataset schema** (see the *Overview* view in the Console results table).

### How to run

1. **Paste a product photo URL** into `imageUrls` (or upload base64 via `imagesBase64`).
2. Set `maxResultsPerImage` (up to 20 matches per image).
3. Optional: switch on `enrichDetails` for full product intelligence.
4. Start the run — results land in the default dataset, one row per image.
5. Re-fetch exact products anytime via `offerIds` (detail-only mode, up to 400).

API:

```bash
curl -X POST "https://api.apify.com/v2/acts/crawleast~1688-image-search-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "imageUrls": ["https://example.com/product-photo.jpg"],
    "maxResultsPerImage": 20,
    "enrichDetails": true,
    "targetMarket": "US"
  }'
```

### Input reference

| Field | Type | Default | Meaning |
| --- | --- | --- | --- |
| `imageUrls` | string\[] | — | Public product photo URLs (jpg/png/webp). Each yields up to `maxResultsPerImage` matches. |
| `imagesBase64` | array | — | Base64 alternative: raw string or `{"base64": "...", "fileName": "x.jpg"}`. Mixable with `imageUrls`. |
| `offerIds` | string\[] | — | Detail-only mode: fetch full details for up to 400 known 1688 offer IDs. Overrides images. |
| `maxImages` | int | `10` | Cap on input images (max 20). Extras are dropped and never charged. |
| `maxResultsPerImage` | int | `20` | Matches per image (1–20), in similarity order. |
| `enrichDetails` | bool | `false` | Upgrade delivered matches to full details ($0.003 each). |
| `targetMarket` | enum | `US` | `US` / `EU` / `UK` / `AU` / `global` — drives landed cost & compliance hints. |
| `maxTotalChargeUsd` | number | `2` | Hard budget cap (min 0.04). The run stops gracefully at the cap and keeps delivered data. |

**Migrating from another actor?** Common aliases get minimal support: `imageUrl` and `images` are mapped to `imageUrls`; `imageFile` is routed by value shape (data:URI / pure base64 → `imagesBase64`, URL → `imageUrls`). Keyword fields like `query` are dropped with a logged warning — this Actor searches by **image**, not keywords. Unknown legacy fields are dropped with a logged warning, so old inputs never crash a run.

### Pricing (pay-per-event)

All-inclusive, predictable pricing — no hidden usage fees. **$0.01 run base fee** (charged once at run completion, only if you received at least one matched image) + **$0.005 per image search** + **$0.003 per enriched detail**. Runs that deliver no matches are not charged.

| Event | Price | When it's charged |
| --- | --- | --- |
| `run-base-fee` | **$0.01** | Once per run, at completion — only when ≥1 match was delivered |
| `image-search` | **$0.005** | Per image search that returns ≥1 match |
| `detail-item` | **$0.003** | Per enriched detail **actually delivered** |

**No start fee. No charge** for failed image downloads, zero-match searches, risk-control blocks, undelivered details or truncated overflow. Subscription discounts (image-search): SILVER −4%, GOLD/PLATINUM/DIAMOND −10% (discount depth capped at 10%); detail-item keeps its own tier schedule.

**Worked examples** (card-only scans, FREE tier):

| Order | Calculation | Total |
| --- | --- | --- |
| 1 image | $0.01 base fee + 1 × $0.005 | **$0.015** |
| 10 images | $0.01 base fee + 10 × $0.005 | **$0.06** |
| 100 images | $0.01 base fee + 100 × $0.005 | **$0.51** |

The flat $0.01 base fee amortizes across the batch — the larger the run, the closer your effective per-image price gets to the raw $0.005.

**Fully enriched example — sourcing 10 products by photo** (FREE tier): 10 image searches ($0.05) + 200 delivered details (10 × 20 matches × $0.003 = $0.60) + $0.01 base fee = **$0.66** for 200 supplier candidates with landed cost.

Compare: one hour of a sourcing agent browsing 1688 manually covers perhaps 5–10 products — and tells you nothing about landed cost or dropship readiness.

> **Best value: batch 10–20 images per run** — one base fee per run, one image-search charge per image, details only when you opt in. Larger batches amortize the base fee and the fixed cold-start cost over more results, so your per-candidate price keeps dropping.

### Limits & caveats (read once, trust us more)

- **Dataset snapshot semantics.** Enrich-mode image runs write progressive full snapshots into the append-only dataset as details arrive. **Consumers should take the last `imageResult` block (20 rows)** — it is the most enriched one. `SUMMARY.imageFlushCount` tells you how many snapshots were written. Card-only runs flush once per image.
- **Cross-image dedup & billing.** Detail targets are deduplicated by `offerId` across query images (measured on our 20-image benchmark: 20 images × 20 matches → **371 unique targets, 371/371 delivered and billed**, run MrWX8o2ZcMFXC2ZQ0). `detail-item` billing counts **unique delivered offers**, so when one supplier appears under several of your photos, the card-level enriched count can exceed the billed count — by design, never double billing. Our delivery discipline: zero loss of deduplicated candidates.
- **Compensation retry.** If some details fail in the parallel pass, ONE automatic serial retry targets only the failed `offerIds` (deadline-permitting). It is billed only on actual delivery and reported in `SUMMARY.compensationRetry` (`triggered`, `offered`, `delivered`, `failed`).
- **Budget cap stops gracefully, never mid-delivery.** When `maxTotalChargeUsd` is hit, the run stops scheduling new work, but details already being fetched are completed and delivered **free of charge** — you never pay for a partial fetch, and you never lose in-flight data. `SUMMARY.chargedEvents` always equals what you were actually billed.
- **1688 risk control is real.** Rarely, 1688's anti-bot layer refuses queries (`status: "RISK_CONTROL"`). Those images are never charged; the run reports per-image status honestly instead of silently retrying forever.
- **Estimates are heuristics.** `estLandedCostUsd` (duty/shipping/platform rates) and `compliance` hints are informational starting points, not quotes or legal advice. `dropshipReadyScore` degrades gracefully (`scoreConfidence`) when the listing hides evidence.
- **Chinese-first source.** 1688 is a domestic Chinese marketplace: original titles are Chinese (`titleCn`) and that field is authoritative. English titles (`titleEn`) are best-effort machine translations (free translation services with a domain dictionary fallback); `translationMethod` tells you which path produced each title. Supplier names stay in Chinese (as registered).
- **Run window.** Up to 20 images × 20 matches per run; large enriched orders (hundreds of details) take several minutes and run under a 40-minute platform window with budget-aware graceful stop.

### FAQ

**How much does it cost to search by image on 1688?**
$0.005 per image search that returns at least one match, plus a $0.01 run base fee charged once at run completion and only if you received at least one match — failed and empty searches are free, and runs that deliver no matches are not charged at all. Adding full details is $0.003 per delivered detail. A typical 10-photo, fully enriched sourcing session costs about $0.66.

**Do I need a 1688 account or Chinese phone number?**
No. The Actor handles access internally; you provide only the photos (or offer IDs).

**What image formats work?**
JPEG, PNG and WebP up to ~1 MB each, via public URL (`imageUrls`) or base64 (`imagesBase64`). Screenshots from TikTok/Amazon/AliExpress work fine.

**What if an image returns no matches?**
`status: "OK"` with `matchCount: 0` and zero charge. Try a cleaner crop — product-only, plain background images match best.

**Why are some details missing fields?**
`dataQuality` tells you (`full` / `partial` / `minimal`). 1688 listings genuinely differ in what they publish (SKU tables, weight, video). What isn't published isn't invented.

**Can I fetch details for products I already found?**
Yes — `offerIds` mode takes up to 400 IDs and returns full enriched details without any image search (no `image-search` charges at all).

**How do I control spend?**
Set `maxTotalChargeUsd` (default $2). At the cap the run stops gracefully and keeps everything already delivered. `SUMMARY.chargedEvents` vs `SUMMARY.intendedEvents` shows the exact billing ledger per run.

**How long does a run take?**
Card-only scans finish in ~30–90 seconds. Enriched runs add ~1 detail/second per identity pool; a 200-detail order typically completes in a few minutes.

**Is this legal?**
The Actor reads publicly available 1688.com listing data at normal browsing rates. Respect 1688's terms and applicable laws; you are responsible for how you use the data.

### Copy to your AI assistant

This Actor is **API-first and agent-ready**: deterministic JSON input/output, per-event billing with a hard budget cap, and machine-readable failure semantics — ideal for MCP servers, n8n/Make flows, LangChain tools and autonomous sourcing agents.

Paste this into your AI assistant:

```text
Use the Apify Actor crawleast/1688-image-search-scraper to find Chinese
wholesale suppliers for a product photo. POST this JSON to
https://api.apify.com/v2/acts/crawleast~1688-image-search-scraper/run-sync-get-dataset-items?token=<APIFY_TOKEN>
body: {"imageUrls": ["<photo-url>"], "maxResultsPerImage": 20,
"enrichDetails": true, "targetMarket": "US", "maxTotalChargeUsd": 2}.
Each dataset row is one query image; the last imageResult block holds the
most enriched matches. Report: minimum landed cost, best dropship grade,
and any compliance risk flags.
```

`runs-sync-get-dataset-items` returns the final dataset in one call — perfect for tool-calling loops. For large enriched orders (hundreds of details), append `?timeout=900` (seconds) to the sync endpoint, or set your HTTP client timeout ≥ 15 minutes — otherwise the gateway may return 408 while the run keeps working in the background (poll `runs/{runId}` to recover).

### Related Actors

- **[1688 Pet Supplies Scraper](https://apify.com/crawleast/china-pet-supplies-scraper)** — keyword-driven 1688 market research for pet products: English titles, MOQ price ladders, dropship scores and landed costs. Use it to *discover* categories, then use this Actor to *source by photo* the winners you find.

Pipeline: discover by keyword (Pet Supplies Scraper) → screenshot the winners → source suppliers by photo (this Actor) → re-check finalists via `offerIds`.

### Reviews & changelog

Found a bug or have a wishlist? Open an **Issue** — a fixed bug helps you more than a one-star rating, and we answer fast.

If this run saved you time, a quick review on the Store page helps other buyers find it — 10 seconds, hugely appreciated.

**Changelog**

- **0.3.0 (2026-08-24)** — W3 productization: input schema v2 (8 buyer fields), dataset/KV/output schemas with the Overview view, tiered subscription discounts, final listing copy.
- **0.2.x (2026-08-23/24)** — W2 core: mtop image search with four-level fallback, bounded detail parallel pool, budget-aware deadlines, compensation retry, billing ledger (SM-01…SM-06 smoke verified; 400-detail benchmark delivered 100% of deduplicated targets).

***

*Data is provided "as is" for research and sourcing decisions. Pricing, scores and compliance hints are heuristic estimates; verify independently before committing funds. Not affiliated with 1688.com / Alibaba Group.*

# Actor input Schema

## `imageUrls` (type: `array`):

Public URLs of product photos to search with (jpg/png/webp, ~1 MB or less each). Each image yields up to maxResultsPerImage matching listings, billed only when at least one match is found. Example: a photo of a product you saw on TikTok/Amazon/AliExpress.

## `imagesBase64` (type: `array`):

Alternative to imageUrls when you have no public URL: base64-encoded images. Each entry is either a raw base64 string or {"base64": "...", "fileName": "product.jpg"}. Mixed use with imageUrls is supported.

## `offerIds` (type: `array`):

Skip image search and fetch full product details directly for these 1688 offer IDs (the numeric ID from a detail.1688.com/offer/<ID>.html URL). Overrides image inputs. Capped at 400 per run; extras are dropped and never charged.

## `maxImages` (type: `integer`):

Maximum number of input images to process. Extras beyond this limit are truncated, never searched and never charged.

## `maxResultsPerImage` (type: `integer`):

How many matching listings to return per image, ordered by visual similarity.

## `enrichDetails` (type: `boolean`):

Fetch full product details for matched offers: SKUs and stock, quantity-break price ladder, English title, weight, dropship-ready score, estimated landed cost (USD) and compliance hints. Billed $0.003 per detail actually delivered; failed details are never charged.

## `targetMarket` (type: `string`):

Destination market used for the estimated landed cost (duty rate) and compliance certification hints on enriched details.

## `maxTotalChargeUsd` (type: `number`):

Hard cap on pay-per-event charges for this run. When the cap is reached the run stops gracefully and keeps everything already delivered. There is no start fee and no charge for failed or empty searches.

## Actor input object example

```json
{
  "imageUrls": [
    "https://example.com/screenshot-of-a-product.jpg"
  ],
  "imagesBase64": [
    {
      "base64": "iVBORw0KGgoAAAANSUhEUgAA...",
      "fileName": "product.jpg"
    }
  ],
  "offerIds": [
    "802207808750"
  ],
  "maxImages": 10,
  "maxResultsPerImage": 20,
  "enrichDetails": false,
  "targetMarket": "US",
  "maxTotalChargeUsd": 2
}
```

# Actor output Schema

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

One row per query image: search status and the matching 1688 listings in similarity order — factory price, MOQ, booked demand and supplier trust signals; with enrichDetails=true each delivered match carries full details (SKUs, price ladder, English title, dropship score, estimated landed cost, compliance hints). Field meanings are described in the dataset schema (Overview view).

## `runSummary` (type: `string`):

Machine-readable run report stored under the SUMMARY key: charged vs intended PPE events, charged USD, per-image search outcomes, detail delivery counters and compensation-retry diagnostics.

# 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 = {
    "imageUrls": [
        "https://cbu01.alicdn.com/img/ibank/15418323391_1847764777.jpg"
    ],
    "imagesBase64": [],
    "offerIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawleast/1688-image-search-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 = {
    "imageUrls": ["https://cbu01.alicdn.com/img/ibank/15418323391_1847764777.jpg"],
    "imagesBase64": [],
    "offerIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("crawleast/1688-image-search-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 '{
  "imageUrls": [
    "https://cbu01.alicdn.com/img/ibank/15418323391_1847764777.jpg"
  ],
  "imagesBase64": [],
  "offerIds": []
}' |
apify call crawleast/1688-image-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawleast/1688-image-search-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/4nHSiNhcVlyNqPfi2/builds/cCNAWWfw5r6V2Tzz1/openapi.json