# Salesforce AppExchange Scraper - Apps & Publisher Leads (`scrapesage/salesforce-appexchange-scraper`) Actor

Scrape Salesforce AppExchange into rich B2B vendor leads: publisher name, email, website, HQ, employees, ratings, reviews, pricing, security review, editions & categories. Filter by keyword, category, rating or HQ country. Monitor mode + email enrichment.

- **URL**: https://apify.com/scrapesage/salesforce-appexchange-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 app listing scrapeds

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/platform/actors/running/actors-in-store#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

## Salesforce AppExchange Scraper — Apps & Publisher (Vendor) Leads

Extract **complete data from the [Salesforce AppExchange](https://appexchange.salesforce.com)** — the world's largest enterprise cloud marketplace (5,000+ apps). For every app you get the full listing **and** its **publisher (the software vendor) as a ready-to-use B2B lead**: company name, **contact email**, **website**, **HQ location**, **employee count**, ratings, reviews, pricing, security-review status, supported editions and categories.

No login, no API key, no browser — fast, reliable JSON extraction straight from AppExchange's own public data API.

### Why this AppExchange scraper?

Most AppExchange scrapers only read the visible app cards and return `null` for the fields that actually matter for outreach. This actor merges the **listing inventory** with each app's **rich detail** and ships the **richest dataset in the category** — every record is both an app and a contactable vendor lead.

| Data | Typical scrapers | This actor |
|---|---|---|
| App name, rating, review count, categories | ✅ | ✅ |
| Pricing model (free / paid / freemium) | partial | ✅ |
| Supported editions, Lightning Ready, app type | ❌ | ✅ |
| **Security Review status** | ❌ | ✅ |
| Publisher **name** | partial | ✅ |
| Publisher **contact email** | ❌ | ✅ when published |
| Publisher **website** | ❌ | ✅ ~100% |
| Publisher **HQ location** & **employee count** | ❌ | ✅ |
| Publisher description | ❌ | ✅ |
| Customer reviews (title, rating, author, company) | ❌ | ✅ opt-in |
| Emails/phones/socials crawled from publisher site | ❌ | ✅ opt-in |
| One deduplicated lead per publisher | ❌ | ✅ opt-in |
| Lead score (0–100) per app & per publisher | ❌ | ✅ |
| No start fee | ❌ many charge one | ✅ |

### Use cases

- **B2B lead generation** — AppExchange publishers are software vendors and ISVs actively selling into the Salesforce ecosystem. Score them by audience and contactability (`publisherEmail`, `publisherWebsite`, `publisherEmployees`, `rating`, `reviewCount`) and feed your CRM or outreach sequence.
- **Partner & ecosystem mapping** — see who builds on Salesforce, in which categories, at what scale, and where they're headquartered.
- **Competitive & market intelligence** — track ratings, review velocity, pricing models, security-review status and new entrants by category.
- **Sales prospecting** — find vendors that complement (or compete with) your product and reach the publisher directly with verified contact data.
- **Recruiting & sourcing** — discover specialist ISVs by category and technology.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Salesforce AppExchange Scraper**, enter keywords and/or categories (or paste specific listing URLs), and click **Start**.
3. Watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "keywords": ["marketing"],
    "categories": ["Sales", "Analytics"],
    "maxItems": 100,
    "includeDetails": true,
    "includeReviews": false,
    "enrichPublisherEmails": false,
    "emitPublisherLeads": false,
    "minRating": 0
}
```

- **keywords** — free-text terms matched against the app name, description and publisher name (kept if it matches ANY term). Leave empty to scan the whole marketplace.
- **categories** — keep only apps in these AppExchange categories (`Sales`, `Marketing`, `Customer Service`, `Analytics`, `IT Administration`, `Productivity`, `Collaboration`, `Finance`, `Human Resources`, `ERP`, `Commerce`, `Integration`, …).
- **startUrls** — specific listings to scrape directly: detail URLs (`…/appxListingDetail?listingId=a0N3u00000Qt7LiEAJ`) or bare listing IDs.
- **maxItems** *(default 100)* — maximum number of app records.
- **includeDetails** *(default true)* — fetch each app's full detail: publisher firmographics, pricing, security review, editions, app type, full description. The core of the lead record.
- **includeReviews** *(default false)* / **maxReviews** — customer reviews per app (title, rating, body, author, company, date).
- **enrichPublisherEmails** *(default false)* — crawl the publisher's own website (home + contact/about, max 3 pages) for emails, phones and socials.
- **emitPublisherLeads** *(default false)* — also output one deduplicated B2B lead per unique publisher (app count, average rating, total reviews, contacts).
- **Filters** — `minRating`, `freeOnly`, `paidOnly`, `lightningReadyOnly`, `securityReviewedOnly`, `withPublisherEmailOnly`, `withWebsiteOnly`, `hqCountries`, `editions`.
- **monitorMode** / **monitorStoreName** — emit only NEW apps versus previous runs (see below).
- **maxScan** — upper bound on listings examined while filtering, so a narrow filter never scans the whole catalog needlessly.
- **proxyConfiguration** — proxy settings; the default Apify Proxy (automatic / datacenter) is enough and cheapest.

### Output

One record per app (`type: "app"`), plus optional deduplicated publisher leads (`type: "publisher"`):

```json
{
    "type": "app",
    "listingId": "a0N3u00000Qt7LiEAJ",
    "name": "Zoom for Lightning",
    "description": "Bring the power of Zoom Meetings and Zoom Phone into Salesforce…",
    "url": "https://appexchange.salesforce.com/appxListingDetail?listingId=a0N3u00000Qt7LiEAJ",
    "productType": "App",
    "rating": 4.1,
    "reviewCount": 120,
    "pricingModel": "free",
    "categories": ["Sales › Sales Intelligence", "Productivity"],
    "primaryCategory": "Sales",
    "businessNeeds": ["Sales", "Marketing", "Customer Service"],
    "supportedEditions": ["Professional", "Enterprise", "Unlimited", "Developer", "Performance"],
    "languages": ["en"],
    "appType": "Package/Platform/App",
    "isLightningReady": true,
    "isManagedPackage": true,
    "securityReviewStatus": "Passed",
    "latestReleaseDate": "2024-06-27",
    "publisherId": "7c2cdc70-96f6-4d88-8b3d-c5144edc42d0",
    "publisherName": "Zoom Video Communications, Inc.",
    "publisherEmail": "info@zoom.us",
    "publisherWebsite": "https://www.zoom.us",
    "publisherEmployees": 7000,
    "publisherHQLocation": "San Jose, CA",
    "publisherCountry": "US",
    "publisherDescription": "Zoom is for you. Zoom is a space where you can connect to others…",
    "leadScore": 78,
    "scrapedAt": "2026-06-24T18:00:00.000Z"
}
```

#### What to expect (field coverage)

AppExchange mixes 1st-party (Salesforce) and 3rd-party publishers, and some firmographics are publisher-supplied, so a few fields are populated only when the vendor filled them in. Verified across the catalog, you can typically expect:

| Field group | Coverage |
|---|---|
| name, url, productType, rating, reviewCount, categories, leadScore | ~100% |
| publisherName, publisherWebsite, publisherDescription | ~90–100% |
| publisherHQLocation, publisherCountry | ~85–95% |
| publisherEmployees | ~65% (publisher-supplied) |
| publisherEmail | present for most 3rd-party ISVs; absent for 1st-party Salesforce listings (use email enrichment to boost) |
| reviews / enrichedEmails / enrichedPhones / socials | only when the matching option is enabled |

A blank field means the publisher didn't publish that data — never that scraping failed. Nothing is dropped, so you always get the richest record available.

### Monitor mode (only new apps)

Turn on **monitorMode** and the actor remembers the listing IDs it has already returned (in a named key-value store) and emits only **new** apps on each subsequent run — a steady feed of new vendors entering the marketplace. It is **orthogonal to [Apify Schedules](https://docs.apify.com/platform/schedules)**: the schedule triggers the run; monitor mode deduplicates that run's records against everything earlier runs already returned.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly with monitor mode to capture new vendors as they list.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/salesforce-appexchange-scraper').call({
    categories: ['Marketing'],
    maxItems: 100,
    enrichPublisherEmails: true,
    emitPublisherLeads: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} apps & publisher leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new vendor leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored category adds new apps.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find marketing apps on AppExchange and list each publisher's website and contact email" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **B2B partner-ecosystem & lead-gen stack**:

- **[HubSpot Solutions Partner Scraper](https://apify.com/scrapesage/hubspot-solutions-partner-scraper)** — certified HubSpot agencies: tier, services, certifications, reviews & leads.
- **[Xero Advisor Scraper](https://apify.com/scrapesage/xero-advisor-scraper)** — Xero-certified accountants & bookkeepers as B2B leads.
- **[Clutch Scraper](https://apify.com/scrapesage/clutch-scraper)** — agencies & B2B service providers with reviews and contacts.
- **[DesignRush Scraper](https://apify.com/scrapesage/designrush-scraper)** — agency directory leads across marketing, web & design.
- **[B2B Agency Scraper](https://apify.com/scrapesage/b2b-agency-scraper)** — agency profiles, services and contact details.
- **[LinkedIn Company Scraper](https://apify.com/scrapesage/linkedin-company-scraper)** — firmographics, headcount and latest posts from company pages.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones and socials from any company website.
- **[TaxBuzz Scraper](https://apify.com/scrapesage/taxbuzz-scraper)** — tax pros & accounting firms as B2B leads.
- **[Google Maps Scraper](https://apify.com/scrapesage/google-maps-scraper)** — local business leads with phone, website and reviews.

### Tips

- **Targeted runs**: combine `categories` + `keywords` for a focused vendor list. Add `withWebsiteOnly` or `withPublisherEmailOnly` for an outreach-ready set.
- **Highest-value leads**: keep `includeDetails` on (default) — it's the difference between an app name and a contactable vendor. Add `enrichPublisherEmails` to lift email coverage for publishers that don't list one on AppExchange.
- **One row per vendor**: turn on `emitPublisherLeads` to also get a deduplicated lead per publisher with their app count and average rating.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to track only newly listed apps and vendors.

### FAQ

**How do I scrape a specific category?** Put it in `categories` (e.g. `Marketing`, `Sales`, `Analytics`). Combine with `keywords` to narrow further, or paste listing URLs into `startUrls` for exact apps.

**Does it need the Salesforce API or a login?** No. This actor reads AppExchange's own public listing data — no Salesforce org, API key, OAuth or browser required.

**Where do publisher emails come from?** From the publisher's AppExchange profile when they list one, plus (optionally) from their own public website with `enrichPublisherEmails`. Salesforce's own 1st-party listings don't expose an email — that's expected.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new apps automatically?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules); optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push new vendor leads into your CRM as they appear.

**A field is empty — why?** Some publishers don't publish an email, employee count or HQ. Fields are blank only when the data doesn't exist, not because the scraper skipped them.

**Is scraping AppExchange legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and Salesforce's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `keywords` (type: `array`):

Free-text terms to match against the app name, description and publisher name (case-insensitive; an app is kept if it matches ANY term). Leave empty to scan the whole marketplace. Example: <code>marketing</code>, <code>data quality</code>, <code>Docusign</code>.

## `categories` (type: `array`):

Only keep apps in these AppExchange categories. Use a friendly term that matches the category name (case-insensitive, partial match): <code>Sales</code>, <code>Marketing</code>, <code>Customer Service</code>, <code>Analytics</code>, <code>IT Administration</code>, <code>Productivity</code>, <code>Collaboration</code>, <code>Finance</code>, <code>Human Resources</code>, <code>ERP</code>, <code>Commerce</code>, <code>Integration</code>. Leave empty for all categories.

## `startUrls` (type: `array`):

Specific AppExchange listings to scrape directly. Paste listing-detail URLs (<code>https://appexchange.salesforce.com/appxListingDetail?listingId=a0N3u00000Qt7LiEAJ</code>) or bare listing IDs (<code>a0N3u00000Qt7LiEAJ</code>). Used in addition to the keyword/category scan.

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

Maximum number of app records to scrape.

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

Fetch each app's detail for the full B2B record: publisher (vendor) name, email, website, HQ location, employee count & description, pricing model, security-review status, supported editions, app type and full description. Turn off for a faster, lighter run that returns only listing-level fields (name, rating, reviews, categories, publisher name).

## `includeReviews` (type: `boolean`):

Fetch customer reviews for each app (title, rating, body, author, company, date). Adds one request per app.

## `maxReviews` (type: `integer`):

How many reviews to keep per app when reviews are enabled.

## `enrichPublisherEmails` (type: `boolean`):

For each app whose publisher has a website, crawl it (home + contact/about, up to 3 pages) to extract contact emails, phone numbers and social links. Boosts contactability for publishers that don't list an email on AppExchange. Requires details.

## `emitPublisherLeads` (type: `boolean`):

In addition to per-app rows, output one deduplicated B2B lead per unique publisher (vendor) with their app count, average rating, total reviews and contact details. Requires details.

## `minRating` (type: `number`):

Only keep apps with at least this average star rating. 0 = no minimum.

## `freeOnly` (type: `boolean`):

Keep only apps that are free to install.

## `paidOnly` (type: `boolean`):

Keep only paid / commercial apps (stronger vendor-spend signal).

## `lightningReadyOnly` (type: `boolean`):

Keep only apps marked Lightning Ready.

## `securityReviewedOnly` (type: `boolean`):

Keep only apps that have passed the Salesforce Security Review. Requires details.

## `withPublisherEmailOnly` (type: `boolean`):

Skip apps where no publisher email is available (from AppExchange or website enrichment). Requires details.

## `withWebsiteOnly` (type: `boolean`):

Skip apps where the publisher has no website. Requires details.

## `hqCountries` (type: `array`):

Only keep apps whose publisher is headquartered in one of these countries / locations (matched against country code and HQ text, e.g. <code>US</code>, <code>United Kingdom</code>, <code>India</code>). Requires details.

## `editions` (type: `array`):

Only keep apps that support at least one of these Salesforce editions. Use the codes <code>PE</code> (Professional), <code>EE</code> (Enterprise), <code>UE</code> (Unlimited), <code>DE</code> (Developer), <code>PP</code> (Performance), <code>GE</code> (Group), <code>EC</code> (Essentials).

## `maxScan` (type: `integer`):

Upper bound on how many listings to examine while applying keyword/category/edition filters. Protects you from scanning the whole 5,000+ catalog when a filter matches few apps.

## `monitorMode` (type: `boolean`):

Remember listing IDs returned in previous runs (in a named key-value store) and emit only NEW apps on each run. Perfect with Apify Schedules for a steady new-vendor feed — it does not conflict with scheduling: the schedule triggers the run, monitor mode deduplicates this run's records against everything earlier runs already returned.

## `monitorStoreName` (type: `string`):

Name of the key-value store that holds the seen-listing memory for monitor mode. Use different names to track independent searches separately (lowercase letters, digits and hyphens only).

## `maxConcurrency` (type: `integer`):

How many API requests to run in parallel. 10 is a good default for the AppExchange API.

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

Proxies to use. The AppExchange API works from plain datacenter IPs, so the default Apify Proxy (automatic) is enough and cheapest.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "maxItems": 100,
  "includeDetails": true,
  "includeReviews": false,
  "maxReviews": 10,
  "enrichPublisherEmails": false,
  "emitPublisherLeads": false,
  "minRating": 0,
  "freeOnly": false,
  "paidOnly": false,
  "lightningReadyOnly": false,
  "securityReviewedOnly": false,
  "withPublisherEmailOnly": false,
  "withWebsiteOnly": false,
  "maxScan": 1500,
  "monitorMode": false,
  "monitorStoreName": "salesforce-appexchange-monitor",
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped AppExchange app and publisher lead records as JSON items in the default dataset.

# 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 = {
    "keywords": [
        "marketing"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/salesforce-appexchange-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 = {
    "keywords": ["marketing"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/salesforce-appexchange-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/salesforce-appexchange-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapesage/salesforce-appexchange-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PSzm12I56wIZhjogk/builds/JUHVe6Ze3e6xuc0Uz/openapi.json