# ATS Jobs, Salary & Hiring-Signal Intelligence (MCP) (`spiky_closet/ats-jobs-hiring-intel`) Actor

Unified 6-ATS jobs, salary & hiring-signal API + MCP in Go: auto-detect Ashby, Greenhouse, Lever, SmartRecruiters, Workday & BambooHR from domains/emails, extract salaries & 80+ JD tech signals, summaries & onlyNewJobs. Independent tool, not affiliated with any ATS vendor.

- **URL**: https://apify.com/spiky_closet/ats-jobs-hiring-intel.md
- **Developed by:** [AdPulse Labs](https://apify.com/spiky_closet) (community)
- **Categories:** Jobs, Lead generation, MCP servers
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 job posting results

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

## Ashby, Greenhouse, Lever, SmartRecruiters, Workday & BambooHR Jobs Scraper — Salary & Equity, 135+ JD Tech-Stack Signals & MCP Server

Unified **6-ATS Jobs Scraper, Salary & Equity Extractor, and B2B Hiring-Signal API + Streamable HTTP MCP Server** built in zero-dependency Go (`128–256 MB` RAM, `$0` proxy cost, no headless browser).

Pass raw **company domains** (`ramp.com`), **work emails** (`ops@stripe.com`), **career page URLs**, or **explicit ATS slugs** — the Actor automatically detects which of the 6 major ATS platforms a company uses (**Ashby, Greenhouse, Lever, SmartRecruiters, Workday, BambooHR**), fetches live public openings, normalizes **salary & equity bands**, extracts **135+ JD tech-stack signals** via deterministic Aho-Corasick scanning, and outputs clean job rows or 1-row-per-company B2B hiring summaries.

***

### Why Use This 6-ATS Jobs Scraper Instead of Single-ATS Scrapers?

| Feature | Single-ATS Scrapers (`Greenhouse` / `Ashby` / `Workday` only) | 3-ATS Manual-Slug Scrapers | **This 6-ATS Jobs Scraper & MCP Server** |
| :--- | :---: | :---: | :---: |
| **Supported ATS Platforms** | 1 ATS | 3 ATS | **6 ATS** (`Ashby`, `Greenhouse`, `Lever`, `SmartRecruiters`, `Workday`, `BambooHR`) |
| **Domain / Work Email Auto-Detect** | No (manual slug required) | No (manual slug required) | **Yes** (`ramp.com`, `ceo@stripe.com`, career URLs, or explicit slugs) |
| **Normalized Salary & Equity Extraction** | Partial / raw | Partial | **Yes** (structured API fields + JD text fallback, annualized USD + `hasEquity`) |
| **135+ JD Tech-Stack Signals** | No | No | **Yes** (deterministic Aho-Corasick scan across 135+ curated languages, AI/ML, cloud, data, security & GTM tools) |
| **Title-Only & Recency Filters** | Rarely | Rarely | **Yes** (`titleKeywords`, `postedWithinDays`, `minSalaryUsd`, `mustMentionTech`) |
| **1-Row B2B Company Hiring Summaries** | No | No | **Yes** (`summaryMode: true` & `POST /screen`) |
| **Incremental `onlyNewJobs` Monitor** | No | No | **Yes** (named KV store dedup; previously seen jobs cost **`$0`**) |
| **Real-Time Streamable HTTP `/mcp`** | Rarely | No | **Yes** (`POST /mcp` + REST `/jobs`, `/screen`, `/detect`) |
| **Pricing** | `$2.00 / 1,000` | `$1.50 / 1,000` + start fee | **`$1.00 / 1,000` (`$0` start fee — 5,000 free jobs/mo on Apify Free tier)** |

***

### Pricing (Pay-Per-Event, `$0` Start Fee)

- **`job-result`**: `$0.0010` per emitted job (`$1.00 / 1,000` on Free tier, down to `$0.0007` on Gold+).
- **`company-summary`**: `$0.0015` per company summary when `summaryMode: true` or calling `POST /screen`.
- **Zero wasted spend**: Filtered-out jobs, unreachable companies, and previously seen `onlyNewJobs` records cost **`$0`**.

***

### 5 Ready-to-Run Recipes

#### 1. Multi-ATS Auto-Detect from Domains & Emails

Just paste company domains or work emails — no need to look up ATS board tokens:

```json
{
  "companies": [
    "ramp.com",
    "stripe.com",
    "anthropic.com",
    "palantir",
    "smartrecruiters:BoschGroup",
    "workday:nvidia:wd5:NVIDIAExternalCareerSite"
  ],
  "maxJobsPerCompany": 10
}
```

#### 2. High-Salary Remote AI & Infrastructure Roles (Title + Recency + Tech Filters)

Filter server-side before billing (filtered-out jobs cost `$0`):

```json
{
  "companies": ["ramp.com", "stripe.com", "anthropic.com", "openai.com"],
  "titleKeywords": ["Staff", "Senior", "Principal"],
  "postedWithinDays": 30,
  "remoteOnly": true,
  "minSalaryUsd": 180000,
  "mustMentionTech": ["Python", "Go", "Kubernetes", "PyTorch"],
  "excludeKeywords": ["Intern", "Contractor"]
}
```

#### 3. B2B Sales / VC Hiring-Signal Screener (`summaryMode: true`)

Emit **1 aggregated row per company** (total open roles, department split, remote %, median salary, top 135+ JD tech-stack signals, detected ATS) for Clay, HubSpot, or CRM enrichment:

```json
{
  "companies": ["ramp.com", "stripe.com", "anthropic.com"],
  "summaryMode": true
}
```

#### 4. Scheduled Incremental New-Job Monitor (`onlyNewJobs: true`)

Run hourly or daily on an Apify Schedule — only newly posted jobs since the previous run are emitted and billed:

```json
{
  "companies": ["ramp.com", "stripe.com", "anthropic.com"],
  "onlyNewJobs": true,
  "monitorStoreName": "my-target-accounts-jobs",
  "titleKeywords": ["VP", "Head of", "Staff", "Principal"]
}
```

#### 5. Real-Time Standby REST API & MCP Server

Use Apify Standby mode for sub-second HTTP calls from Clay, n8n, Make, Zapier, or AI agents:

- `GET /healthz` — health check
- `GET /detect?company=ramp.com` — detect ATS platform, slug, and public board URL
- `GET /jobs?company=stripe.com&titleKeywords=Staff,Senior&postedWithinDays=30&remoteOnly=true&maxResults=10` — fetch filtered jobs
- `POST /jobs` — batch multi-company job search with full filter JSON
- `POST /screen` — B2B company hiring-signal summary screener (`summaryMode`)
- `POST /mcp` — Streamable HTTP MCP server (`2025-03-26`)

***

### Real Sample JSON Outputs

#### Sample `JobPosting` Record (`recordType: "job"`)

```json
{
  "recordType": "job",
  "jobId": "ashby:ramp:a1b2c3d4-5678-90ab-cdef-1234567890ab",
  "nativeId": "a1b2c3d4-5678-90ab-cdef-1234567890ab",
  "ats": "ashby",
  "companySlug": "ramp",
  "companyName": "Ramp",
  "companyDomain": "ramp.com",
  "title": "Staff Backend Engineer, Risk Infrastructure",
  "department": "Engineering",
  "normalizedDepartment": "Engineering",
  "team": "Risk & Core Platform",
  "location": "New York, NY (Remote Eligible)",
  "locations": ["New York, NY", "Remote - US"],
  "workplaceType": "remote",
  "isRemote": true,
  "employmentType": "FullTime",
  "seniority": "staff",
  "salaryMin": 225000,
  "salaryMax": 275000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "salaryAnnualMinUsd": 225000,
  "salaryAnnualMaxUsd": 275000,
  "salaryRaw": "$225,000 - $275,000 + equity",
  "hasEquity": true,
  "techStack": ["Python", "Go", "PostgreSQL", "Kafka", "Kubernetes", "AWS"],
  "techCategories": {
    "languages": ["Go", "Python"],
    "databases": ["PostgreSQL"],
    "data_streaming": ["Kafka"],
    "cloud_infra": ["AWS", "Kubernetes"]
  },
  "jobUrl": "https://jobs.ashbyhq.com/ramp/a1b2c3d4-5678-90ab-cdef-1234567890ab",
  "applyUrl": "https://jobs.ashbyhq.com/ramp/a1b2c3d4-5678-90ab-cdef-1234567890ab/application",
  "publishedAt": "2026-04-12T15:30:00Z",
  "updatedAt": "2026-04-14T18:05:00Z",
  "descriptionSnippet": "Build low-latency financial risk services in Python and Go backed by PostgreSQL, Kafka, and Kubernetes on AWS...",
  "scrapedAt": "2026-04-15T12:00:00Z"
}
```

#### Sample `CompanyHiringSummary` Record (`recordType: "company_summary"`, `summaryMode: true` or `POST /screen`)

```json
{
  "recordType": "company_summary",
  "companyName": "Ramp",
  "companyDomain": "ramp.com",
  "companySlug": "ramp",
  "ats": "ashby",
  "boardUrl": "https://jobs.ashbyhq.com/ramp",
  "status": "ok",
  "totalOpenJobs": 142,
  "matchedJobs": 142,
  "remoteJobs": 54,
  "hybridJobs": 71,
  "onsiteJobs": 17,
  "remoteSharePct": 38.0,
  "departmentCounts": {
    "Engineering": 64,
    "Sales": 31,
    "AI/ML & Data": 18,
    "Product": 12,
    "Security": 7,
    "Operations": 10
  },
  "seniorityCounts": {
    "mid": 42,
    "senior": 68,
    "staff": 16,
    "manager": 11,
    "director": 5
  },
  "topTechStack": [
    { "name": "Python", "category": "languages", "count": 58 },
    { "name": "TypeScript", "category": "languages", "count": 41 },
    { "name": "PostgreSQL", "category": "databases", "count": 37 },
    { "name": "AWS", "category": "cloud_infra", "count": 35 },
    { "name": "Kubernetes", "category": "cloud_infra", "count": 29 }
  ],
  "topTechNames": "Python, TypeScript, PostgreSQL, AWS, Kubernetes",
  "topLocations": [
    { "name": "New York, NY", "count": 88 },
    { "name": "San Francisco, CA", "count": 34 },
    { "name": "Remote - US", "count": 20 }
  ],
  "jobsWithSalary": 134,
  "jobsWithEquity": 128,
  "medianSalaryMidUsd": 215000,
  "minSalaryUsd": 95000,
  "maxSalaryUsd": 380000,
  "isHiringAi": true,
  "isHiringSales": true,
  "isHiringSecurity": true,
  "isHiringLeadership": true,
  "hiringSignals": [
    "Hiring AI/ML & Data",
    "Scaling Sales/GTM",
    "Investing in Security",
    "Executive/Director Hiring",
    "Offers Equity"
  ],
  "newestJobAt": "2026-04-14T21:10:00Z",
  "scrapedAt": "2026-04-15T12:00:00Z"
}
```

***

### Clay, n8n & Make HTTP Integration Recipe

Enrich any CRM table, Clay account list, or n8n/Make workflow directly from a company domain or work email using the Standby HTTP endpoint:

- **Method:** `POST`
- **URL:** `https://<your-actor-standby-url>/screen` (1-row B2B hiring summary) or `https://<your-actor-standby-url>/jobs` (individual job listings)
- **Headers:**
  - `Authorization: Bearer <YOUR_APIFY_TOKEN>`
  - `Content-Type: application/json`
- **Body (Clay / n8n / Make dynamic variable example):**

```json
{
  "companies": ["{{Company Domain}}"],
  "postedWithinDays": 60
}
```

- **cURL Quick Test:**

```bash
curl -X POST "https://<your-actor-standby-url>/screen" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["ramp.com", "ceo@stripe.com"], "postedWithinDays": 60}'
```

Map `totalOpenJobs`, `topTechNames`, `medianSalaryMidUsd`, `isHiringAi`, `isHiringSales`, `hiringSignals`, and `ats` straight into Clay columns, HubSpot properties, or Slack alerts.

***

### MCP Server Configuration (Claude Desktop, Cursor, Windsurf, OpenAI Agents)

Point any Streamable HTTP MCP client at your Apify Standby URL with your Apify API token:

```json
{
  "mcpServers": {
    "ats-jobs-hiring-intel": {
      "url": "https://<your-actor-standby-url>/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_APIFY_TOKEN>"
      }
    }
  }
}
```

#### Exposed MCP Tools

1. **`get_company_jobs`** — Fetch normalized jobs with salary & equity bands, workplace type, seniority, department, and **135+ JD tech-stack signals** across 6 ATS platforms (supports `titleKeywords`, `postedWithinDays`, `minSalaryUsd`, `mustMentionTech`, and `remoteOnly`).
2. **`detect_company_ats`** — Auto-detect which ATS (`ashby`, `greenhouse`, `lever`, `smartrecruiters`, `workday`, `bamboohr`) and board slug a company domain, email, or career URL uses.
3. **`screen_hiring_signals`** — Return 1-row-per-company B2B hiring intelligence (open role velocity, department mix, remote ratio, median USD salary, top JD tech stack).

***

### Drop-In Input Aliases

Migrating from another ATS scraper? The Actor accepts common field aliases automatically:

- Company targets: `companies`, `domains`, `slugs`, `urls`, `startUrls`, `companyUrls`, `bulkCompanies`
- Search & caps: `keywords`, `titleKeywords`, `query`, `postedWithinDays`, `maxResults`, `maxItems`, `maxJobsPerCompany`

***

### Frequently Asked Questions (FAQ)

#### How many jobs can I scrape on the Apify Free tier?

The Apify Free plan includes `$5/month` in platform credit. With `$0` start fee and `$0.0010` per emitted job (`$1.00 / 1,000`), that covers **up to 5,000 matched jobs per month** (or over **3,300 company hiring summaries**). Filtered-out jobs and previously seen `onlyNewJobs` records cost `$0`.

#### How do Workday and BambooHR boards work?

Pass a company domain (`example.com`), career URL, or explicit slug (`workday:nvidia:wd5:NVIDIAExternalCareerSite` or `bamboohr:yourcompany`). For standard domains, the detector checks public ATS endpoints and career-page embeds automatically. If an enterprise Workday tenant uses a custom site name, passing the Workday career URL or `workday:<tenant>:<wd-host>:<site>` guarantees an exact match.

#### How does deduplication and `onlyNewJobs` work?

Input targets are deduplicated automatically across `companies` and `bulkCompanies`. When `onlyNewJobs: true` is enabled, the Actor stores seen `jobId` keys in the named Apify Key-Value Store (`monitorStoreName`, default `ats-jobs-monitor-state`) across scheduled runs, emitting and billing only newly posted roles.

#### How do I connect this Actor to Claude Desktop, Cursor, or another MCP client?

Enable Standby mode on Apify (enabled by default), copy your Actor Standby URL, and add `https://<your-actor-standby-url>/mcp` with `Authorization: Bearer <YOUR_APIFY_TOKEN>` to your MCP client config as shown above. The server implements Streamable HTTP MCP (`POST /mcp`).

***

### Honest Limitations

- **Public ATS boards only**: Queries official public career board endpoints for Ashby, Greenhouse, Lever, SmartRecruiters, Workday, and BambooHR. Does not scrape LinkedIn, Indeed, Glassdoor, or login-walled portals.
- **Custom / enterprise career sites**: If a company hosts a proprietary careers site with no public ATS embed or uses a non-standard Workday tenant/site path, auto-detection may return `unknown`. In those cases, pass the career URL or explicit slug (e.g. `workday:nvidia:wd5:NVIDIAExternalCareerSite` or `greenhouse:stripe`).
- **Salary availability**: Structured salary fields are extracted whenever published by the employer (highest coverage on Ashby and US pay-transparency postings); postings without compensation text leave salary fields empty/zero rather than guessing.
- **Workday descriptions**: Workday's listing API returns summaries without full HTML descriptions unless individual job detail endpoints are fetched; tech signals and salaries for Workday are extracted from available title/metadata/snippet fields.

***

### Disclaimer

This Actor is an independent data-integration and intelligence tool developed by AdPulse Labs. It is **not affiliated with, endorsed by, or sponsored by** Ashby, Greenhouse, Lever, SmartRecruiters, Workday, BambooHR, or any listed employer.

# Actor input Schema

## `companies` (type: `array`):

Paste company domains ('ramp.com', 'stripe.com'), work emails ('ops@anthropic.com'), career URLs, or explicit ATS slugs ('ashby:ramp', 'lever:palantir', 'smartrecruiters:BoschGroup', 'workday:nvidia:wd5:NVIDIAExternalCareerSite'). Click Start right away to test with the 3 prefilled companies.

## `bulkCompanies` (type: `string`):

Paste a newline- or comma-separated list of company domains, emails, career URLs, or ATS slugs. Duplicates are removed automatically.

## `summaryMode` (type: `boolean`):

Emit one aggregated B2B hiring-signal summary per company (total open roles, department split, remote share, median salary, top JD tech stack, detected ATS) instead of individual job rows. Ideal for Clay, HubSpot, and VC sourcing.

## `onlyNewJobs` (type: `boolean`):

Tracks previously seen job IDs in a named Apify Key-Value Store and emits only newly posted roles. Previously seen jobs cost $0.

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

Named Apify Key-Value Store used to persist seen job IDs across scheduled runs (default: 'ats-jobs-monitor-state').

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

Keep only jobs matching ANY of these keywords across the title, department, or full job description (case-insensitive, e.g. \['Staff Engineer', 'Account Executive', 'AI']). Use 'Title-Only Keywords' below to match job titles exclusively. Filtered-out jobs cost $0.

## `titleKeywords` (type: `array`):

Keep only jobs whose job title matches ANY of these keywords (case-insensitive, e.g. \['Staff', 'Principal', 'Founding', 'VP']). Unlike 'Include Keywords' (which searches full job descriptions), this matches job titles only. Filtered-out jobs cost $0.

## `excludeKeywords` (type: `array`):

Exclude jobs containing ANY of these keywords in the title or description (e.g. \['Intern', 'Contractor']).

## `remoteOnly` (type: `boolean`):

Keep only jobs classified as remote.

## `departments` (type: `array`):

Keep only jobs matching ANY listed department (e.g. \['Engineering', 'Sales', 'Product', 'Data', 'Security']).

## `locations` (type: `array`):

Keep only jobs whose location matches ANY listed region, city, or country (e.g. \['New York', 'San Francisco', 'London', 'United States']).

## `minSalaryUsd` (type: `integer`):

Keep only jobs with a parsed annualized USD salary band meeting or exceeding this floor (0 = disabled).

## `mustMentionTech` (type: `array`):

Keep only jobs mentioning ANY of these technologies in their job description (e.g. \['Kubernetes', 'Snowflake', 'Salesforce', 'PyTorch', 'Go']).

## `postedWithinDays` (type: `integer`):

Only return jobs posted within the last N days (0 = all dates).

## `maxJobsPerCompany` (type: `integer`):

Cap the number of matching jobs emitted per company (0 = no per-company cap; Console UI prefills 10 for fast previews while API calls remain unlimited by default).

## `maxResults` (type: `integer`):

Hard cap on total records emitted across the run (0 = no cap; free-tier cloud runs default to 100).

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

Number of company boards queried concurrently.

## `includeDescriptionText` (type: `boolean`):

Include a clean plain-text excerpt of each job description in output records.

## Actor input object example

```json
{
  "companies": [
    "ramp.com",
    "stripe.com",
    "anthropic.com"
  ],
  "summaryMode": false,
  "onlyNewJobs": false,
  "monitorStoreName": "ats-jobs-monitor-state",
  "remoteOnly": false,
  "minSalaryUsd": 0,
  "postedWithinDays": 0,
  "maxJobsPerCompany": 10,
  "maxResults": 0,
  "maxConcurrency": 8,
  "includeDescriptionText": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `compensationTech` (type: `string`):

No description

## `companySummaries` (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 = {
    "companies": [
        "ramp.com",
        "stripe.com",
        "anthropic.com"
    ],
    "maxJobsPerCompany": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("spiky_closet/ats-jobs-hiring-intel").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 = {
    "companies": [
        "ramp.com",
        "stripe.com",
        "anthropic.com",
    ],
    "maxJobsPerCompany": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("spiky_closet/ats-jobs-hiring-intel").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 '{
  "companies": [
    "ramp.com",
    "stripe.com",
    "anthropic.com"
  ],
  "maxJobsPerCompany": 10
}' |
apify call spiky_closet/ats-jobs-hiring-intel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,spiky_closet/ats-jobs-hiring-intel"
        }
    }
}
```

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/2fVOiQU85kvAFf8va/builds/cgLogqIMkyWbkzjas/openapi.json
