# Halfords Scraper: UK Car Parts, Tyres, Bikes & Prices (`recordsdata/halfords-scraper`) Actor

Scrape halfords.com: car parts, tyres by size, bikes and services with GBP price, sale and member price, stock, click and collect, EAN, part number, rating and category. Search or lookup, price monitoring. Export JSON, CSV or Excel.

- **URL**: https://apify.com/recordsdata/halfords-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.00 / 1,000 product rows

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/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

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## Halfords Scraper: UK Car Parts, Tyres and Cycling Data

> Halfords Scraper is an Apify Actor that extracts products from halfords.com, the UK retailer of car parts, tyres, tools, bikes and servicing. Each row has the GBP price, sale price, member price, stock, click and collect and home delivery flags, rating, brand, EAN, part number and category, and tyres come with the size, EU label grades and season. No login, browser or proxy is needed.

Export the result as JSON, CSV, Excel, XML or HTML, or read it through the Apify API. A run of 3 results takes about 5 seconds in the cloud (median 4.6 seconds over 14 test runs).

### What can you scrape from Halfords?

- **Car parts and accessories**: brake discs, wiper blades, batteries, bulbs, oil, tools, car audio and more. Each row has the title, brand when Halfords states it, manufacturer part number, EAN, category path, specifications, features, description and photos.
- **Tyres, one row per size**: `tireSize` as printed plus width, aspect ratio, rim diameter, load index, speed rating, season, wet grip, fuel efficiency, noise level, run flat, 3PMSF snow mark and the EU label id.
- **Bikes and cycling parts**: bikes, parts, clothing and accessories with price, sale price and stock.
- **Services**: MOT, car servicing and fitting products, with the price range of the service family.
- **Prices**: selling price, list price and discount percent when on sale, member (Motoring Club) price, and the highest price of a family such as a tyre pattern.
- **Availability**: orderable online, stock status, units left when Halfords shows them, click and collect, reserve in store, home delivery and mobile fitting flags.
- **Catalog categories**: one row per category with its id, parent, level and the number of product pages under it.
- **Price and stock changes**: with monitoring on, a product whose price or stock moved comes back with the previous price and the difference.

### Why use this Halfords scraper?

- **Built for this one retailer**: the actor reads the same product data the Halfords pages use, so prices, stock and tyre grades are the site's own values, not guesses.
- **Two ways to read**: scan the catalog with filters, or look up exact product addresses and ids.
- **Tyre size search**: Halfords lists tyres by pattern. The actor opens each pattern and returns only the sizes you asked for, such as 205/55 R16.
- **Prices in GBP**: every row says `GBP` and `GB`.
- **Clean output**: typed numbers, no `null` fillers, the same column order every run.
- **Polite by design**: at most 5 requests per second, `robots.txt` honoured, no login.

### How to scrape Halfords in four steps

1. Create a free account at [console.apify.com](https://console.apify.com) and open the actor.
2. Choose **Where to read from**: search the catalog, or look up product addresses and ids.
3. Add search text, categories, brands, a tyre size, a price range or other filters, and set the maximum number of items.
4. Click **Start**, then download the dataset from the **Storage** tab.

A minimal input that returns the first 100 Michelin tyres in size 205/55 R16 that can be ordered:

```json
{
  "mode": "search",
  "tyreSize": "205/55 R16",
  "brands": ["Michelin"],
  "inStockOnly": true,
  "maxItems": 100
}
```

### What data do you get from Halfords?

Every row has a `recordType`: `part`, `tire` or `category`. The dataset has 83 keys (82 data fields plus `error`). Fields that do not apply, or that the page does not give, are left out.

| Field | Description |
|---|---|
| `recordType`, `sourceSite`, `country`, `listingType`, `vehicleType` | Row type, `halfords.com`, `GB`, `sale` or `service`, and `part`, `tire`, `bicycle` or `service` |
| `title`, `listingId`, `url`, `imageUrl` | Product name, Halfords product id, product address, main photo |
| `productType`, `masterId`, `variantCount`, `variants` | `item`, `variant`, `master`, `bundle` or `set`; the family a size belongs to; number of sizes or options; the list of them when asked for |
| `brand`, `partNumber`, `ean`, `condition`, `countryOfOrigin` | Brand, manufacturer part number, barcode, `new`, `used` or `ex-display`, country code |
| `categoryPath`, `categoryId`, `parentCategoryId`, `level`, `productCount` | Category trail and id; for category rows the parent, depth and product pages below it |
| `price`, `currency`, `listPrice`, `discountPercent`, `onSale`, `memberPrice`, `priceMax` | Selling price, `GBP`, price before the sale, discount percent, sale flag, member price, highest price of a family |
| `available`, `stockStatus`, `stockQuantity`, `minOrderQuantity` | Orderable online, `in stock`, `out of stock`, `pre-order` or `backorder`, units left when shown, minimum quantity |
| `homeDelivery`, `clickAndCollect`, `reserveInStore`, `mobileFitting` | Fulfilment options Halfords offers for the product |
| `rating`, `reviewCount`, `badges`, `minimumAge` | Average rating and number of reviews, promo badges, age limit |
| `tireSize`, `tireWidthMm`, `tireAspectRatio`, `rimInches`, `loadIndex`, `speedRating` | Tyre size label and its numbers, load index, speed rating |
| `tireSeason`, `wetGrip`, `fuelEfficiency`, `noiseDb`, `noiseClass`, `tireClass`, `euLabelId` | Season, EU label grades, noise, tyre class, EU label id |
| `extraLoad`, `runFlat`, `iceGrip`, `threePeakSnow`, `directional`, `asymmetric`, `electricVehicleTire` | Tyre features |
| `tireSegment`, `tirePattern`, `vehicleCategories`, `approvedFor` | Budget or premium segment, pattern name, car, van or 4x4, vehicle makers that approve it |
| `description`, `features`, `specifications`, `images`, `imageCount`, `videoUrl` | Description text, feature bullets, specification table, photo links, video link |
| `publishedAt`, `updatedAt` | Date the product went on sale, and the last-modified date in the Halfords sitemap |
| `previousPrice`, `priceChange`, `priceChangePct`, `changeType` | Monitoring: earlier price, difference, percent, change label |
| `sellerName`, `sellerUrl`, `isPrivateSeller`, `scrapedAt` | `Halfords`, its site, `false`, time of the read |

#### Sample output

A real `part` row for a product on sale:

```json
{
  "title": "Shimano XT PD-T8000 MTB SPD Trekking Pedals",
  "recordType": "part",
  "listingId": "344457",
  "url": "https://www.halfords.com/cycling/pedals-pegs/shimano-xt-pd-t8000-mtb-spd-trekking-pedals-344457.html",
  "sourceSite": "halfords.com",
  "country": "GB",
  "listingType": "sale",
  "vehicleType": "part",
  "productType": "item",
  "partNumber": "PDT8000",
  "ean": "4524667749493",
  "brand": "Shimano",
  "condition": "new",
  "categoryPath": ["Cycling", "Bike Parts", "Pedals"],
  "price": 79.99,
  "currency": "GBP",
  "listPrice": 99.99,
  "discountPercent": 20,
  "onSale": true,
  "available": true,
  "stockStatus": "in stock",
  "stockQuantity": 10,
  "homeDelivery": true,
  "clickAndCollect": true,
  "reserveInStore": false,
  "rating": 5,
  "reviewCount": 3,
  "badges": ["Online Exclusive", "Deal"],
  "countryOfOrigin": "MY",
  "publishedAt": "2016-12-06",
  "updatedAt": "2026-09-24",
  "sellerName": "Halfords"
}
```

A real `tire` row (description and photos shortened):

```json
{
  "title": "Avon WT7 (205/55 R16 91T)",
  "recordType": "tire",
  "listingId": "4182031",
  "vehicleType": "tire",
  "productType": "variant",
  "masterId": "wt7",
  "brand": "Avon",
  "price": 149.99,
  "currency": "GBP",
  "memberPrice": 142.49,
  "available": false,
  "stockStatus": "out of stock",
  "clickAndCollect": true,
  "mobileFitting": true,
  "tireSize": "205/55 R16",
  "tireWidthMm": 205,
  "tireAspectRatio": 55,
  "rimInches": 16,
  "loadIndex": 91,
  "speedRating": "T",
  "tireSeason": "Winter",
  "wetGrip": "B",
  "fuelEfficiency": "E",
  "noiseDb": 71,
  "tireClass": "C1",
  "iceGrip": true,
  "threePeakSnow": false,
  "vehicleCategories": ["car"],
  "variantCount": 25
}
```

### How the filters work

- **Search text** is matched against the product address, which holds the brand, the product name, the category folders and the product id. A word that is only in the description, the part number or the EAN is not found. To read a product by its id, use mode Lookup.
- **Categories** take a folder such as `cycling/bike-parts` or `motoring/car-parts/brakes`, or a full halfords.com category address. Everything below the folder is included, and an unknown folder returns a free error row.
- **Brands** use the brand field. Halfords leaves the brand empty on many car parts (for example Bosch brake discs), so when it is empty the first words of the product name stand in.
- **Tyre size** accepts `205/55 R16`, `205/55` or `R16`. The sitemap lists only a few sizes of each tyre pattern, so the actor opens the pattern page and reads every matching size (two requests per row).
- **Price range, in stock only, on sale only and minimum rating** are checked on the product page, so each candidate page is read. Combine them with a category, brand or search text to keep the run short.
- **Updated since** uses the last-modified date of each page in the Halfords sitemap.
- **Maximum items** counts every row. **Maximum scan time** (default 900 seconds) stops a long scan and keeps the rows found.

### Monitor Halfords price and stock changes

Switch on **Only new items (monitor)** and the actor remembers every product it delivered in a named key-value store of your own account (`halfords-seen`). Scheduled runs of the same search return only products it has not delivered before; a second run with nothing new returns 0 rows and charges nothing. Add **Also return price and stock changes** and a product whose price or stock changed comes back with `previousPrice`, `priceChange`, `priceChangePct` and `changeType` (`price-drop`, `price-increase`, `out-of-stock` or `back-in-stock`).

### How does it compare with other options?

On 2026-10-23 the Apify Store had two other actors for halfords.com. They publish 16 and 26 fields per product, with the price, brand, EAN, stock flag, rating and category. This actor returns up to 83 columns and adds what they do not publish: tyre size numbers and EU label grades, member price, list price and discount, click and collect, home delivery and mobile fitting flags, stock quantity, the sizes of a tyre pattern, services, category rows and built-in price monitoring.

| | Halfords Scraper | A generic e-commerce scraper |
|---|---|---|
| Tyre sizes | One row per size with width, aspect ratio, rim and EU label grades as numbers and letters | One item with the size list as text |
| Prices | Price, list price, discount, member price and price range | Usually one price |
| Fulfilment | Click and collect, reserve in store, home delivery, mobile fitting | Not part of a generic page layout |
| Filters | Category, brand, tyre size, price, stock, sale, rating, update date | Depends on the tool |
| Monitoring | Built in, with previous price and type of change | Usually left to you |

### Is it legal to scrape Halfords? Limits and responsible use

The actor reads public product pages without logging in, at a paced rate (at most 5 requests per second, slower if the site signals a block), and it follows the `robots.txt` of halfords.com. It does not use the site search, the basket or the registration lookup, which `robots.txt` disallows. It collects public product data only, no personal data, and never reads reviewer names. A retailer catalog can be protected by copyright and database rights, so check that your use of the data is allowed before you rely on it.

- **No vehicle fitment.** Halfords shows which parts fit a car only after a registration number is entered, and `robots.txt` disallows those pages, so the rows carry no fitment list.
- **Search words are checked against the product address.** A product whose address lacks the word can be missed.
- **Narrow page filters read many pages.** A product page is about 1.3 MB and the actor reads up to 5 pages per second. The whole catalog has about 65,000 pages, so a full scan does not fit in one run. Slice by category, brand or tyre size.
- **Tyre stock changes during the day.** `available` and `stockQuantity` describe the moment of the read.

### Use with AI agents (MCP)

Connect the Apify MCP server to Claude, Cursor or another MCP client and this actor appears as a tool: `https://mcp.apify.com?tools=RecordsData/halfords-scraper`.

Example prompt: "List winter tyres in size 205/55 R16 on halfords.com with price, wet grip grade and stock." The agent sends `{ "mode": "search", "tyreSize": "205/55 R16", "maxItems": 50 }` and filters the rows by `tireSeason`.

### Run it from code

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('RecordsData/halfords-scraper').call({
    mode: 'search',
    categories: ['cycling/bike-parts'],
    onSaleOnly: true,
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].price, items[0].listPrice);
```

### Frequently Asked Questions

#### Can I scrape Halfords prices and stock?

Yes. Every product row has the GBP selling price, the list price and discount when on sale, the member price when Halfords shows one, the orderable flag and, for many products, the number of units left. Run it on a schedule with the monitor on to track changes from one run to the next.

#### Can I get Halfords tyres by size?

Yes. Tyres come back as one row per size, with `tireSize` as printed and numeric width, aspect ratio and rim diameter, plus load index, speed rating, season and the EU label grades. Set **Tyre size** to `205/55 R16`, `205/55` or `R16`.

#### Does it return which parts fit my car?

No. Halfords shows fitment only after a vehicle registration is entered, and the site blocks those pages for robots, so the actor does not read them. Search by part type, brand or category instead.

#### Why is the brand missing on some products?

Halfords leaves the brand empty on many car parts. The actor leaves `brand` out instead of guessing, and the **Brands** filter then uses the first words of the product name.

#### Do I need a proxy, a login or an API key?

No. Halfords answers ordinary browser-style requests from Apify servers, with no blocked request in the test runs. A proxy setting exists but is off by default, and the actor does not need an account on the site. You only need an Apify account to start runs.

#### Is it legal to scrape Halfords?

The actor reads publicly visible product pages and no personal data, and it follows `robots.txt`. Catalog data can be protected by copyright and database rights, so you are responsible for checking that your use is allowed before you rely on it. Contact: contact.punkrecordsdata@gmail.com.

#### How many products can I get in one run?

The sitemap lists about 65,000 pages. A run is bounded by **Maximum items** and **Maximum scan time**, and the actor reads up to 5 pages per second, so slice a large export by category, brand or tyre size.

#### How do I get only products on sale?

Switch on **On sale only**. The filter keeps products whose list price is above the selling price. Add a category to keep the scan short.

#### How do I get only new products or changes since my last run?

Switch on **Only new items**, and add **Also return price and stock changes** to also receive products whose price or stock changed. The memory is kept in your own key-value store under the monitor name, and **Forget what was seen** clears it.

#### What happens when the search finds nothing or the input is wrong?

A search with no matches ends the run as succeeded with no rows and no charge. A wrong input, such as a minimum price above the maximum, an unknown category or an unknown product id, returns one free error row with the reason, so a typo never costs you money.

### Support

Questions, a missing field or a feature request: contact.punkrecordsdata@gmail.com. Reviews on the actor page help other people find it.

# Actor input Schema

## `mode` (type: `string`):

Search scans the Halfords catalog (about 65,000 pages) and keeps what passes your filters. Lookup reads exactly the product pages and product ids you list in Addresses and Product ids.

## `recordTypes` (type: `array`):

Products (one row per part, accessory, bike, tyre size or service) and categories (one row per catalog folder with its product count). Categories need mode Search.

## `searchQueries` (type: `array`):

Optional. Words to look for, for example brake discs, wiper blade or Shimano pedals. Every word of one text must appear (any order, case ignored; numbers match as whole numbers) in the product address, which holds the brand, the product name, the category folders and the product id; a row passes when any of the texts matches. A word that is only in the description, part number or EAN is not found: use mode Lookup with the product id for those.

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

Optional. Catalog folders to read, as a path such as cycling/bike-parts or motoring/car-parts/brakes, or a full halfords.com category address. Everything below the folder is included. An unknown folder returns a free error row.

## `brands` (type: `array`):

Optional. Keep only these brands, for example Bosch, Michelin or Shimano. The brand field decides; when Halfords leaves it empty (common for car parts) the first words of the product name stand in.

## `vehicleType` (type: `string`):

Optional. Parts and accessories, tyres (one row per size), bicycles or services such as MOT, servicing and fitting.

## `tyreSize` (type: `string`):

Optional. Keep only tyres of this size, for example 205/55 R16, 205/55 or R16. Halfords lists tyres by pattern, so every size of each pattern is read from its page (two requests per row). Leave empty for all sizes.

## `minPrice` (type: `number`):

Optional. Lowest price in pounds. A product with a price range passes when its range overlaps the wanted range.

## `maxPrice` (type: `number`):

Optional. Highest price in pounds.

## `inStockOnly` (type: `boolean`):

Skips products that Halfords shows as not orderable online.

## `onSaleOnly` (type: `boolean`):

Keeps only products with a reduced price (a list price above the selling price).

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

Optional. Keeps products with at least this customer rating (0 to 5). Products without reviews are left out when this is set.

## `modifiedSince` (type: `string`):

Optional, mode Search. A date such as 2026-10-01. Keeps pages whose last-modified date in the Halfords sitemap is that day or later.

## `sortBy` (type: `string`):

Mode Search. Sitemap order starts returning rows right away. Recently updated reads the whole sitemap first, then returns the newest pages first.

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

Used in mode Lookup. Product pages of halfords.com, for example https://www.halfords.com/cycling/pedals-pegs/shimano-xt-pd-t8000-mtb-spd-trekking-pedals-344457.html. In mode Search, category addresses are used as category filters.

## `productIds` (type: `array`):

Used in mode Lookup. Halfords product ids, the number at the end of a product address (344457). An id the site does not know returns a free error row.

## `includeDescription` (type: `boolean`):

Adds the product description as plain text. Turn it off for smaller rows.

## `includeVariants` (type: `boolean`):

A tyre pattern page (master) lists every size with its id, name and price. Turn this on to add that list to the pattern row.

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

Stops after this many rows (all record types together). Free plans are limited to 10 items per run.

## `onlyNew` (type: `boolean`):

Skips every item seen in an earlier run with the same monitor name, so scheduled runs return only what is new and you pay only for those.

## `trackPriceChanges` (type: `boolean`):

With only new items on, a product already seen comes back when its price or stock changed, with the previous price, the change and a price-drop, price-increase, out-of-stock or back-in-stock label.

## `stateKey` (type: `string`):

Name of the memory used by only new items. Use one name per saved search. Empty derives a name from your filters.

## `resetSeen` (type: `boolean`):

Clears the memory of this monitor before the run, so everything counts as new again.

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

How many pages are read at the same time. The actor also paces every request to at most 5 per second.

## `maxScanSeconds` (type: `integer`):

Stops reading after this time and keeps the rows found so far. A product page is about 1.3 MB, and the actor reads up to 5 pages per second, so a narrow filter over the whole catalog can take the full time.

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

Optional. Empty means direct requests, which work. Add a proxy only if your own network needs one.

## Actor input object example

```json
{
  "mode": "search",
  "recordTypes": [
    "products"
  ],
  "searchQueries": [
    "brake discs"
  ],
  "vehicleType": "all",
  "inStockOnly": false,
  "onSaleOnly": false,
  "sortBy": "sitemap",
  "includeDescription": true,
  "includeVariants": false,
  "maxItems": 10,
  "onlyNew": false,
  "trackPriceChanges": false,
  "stateKey": "",
  "resetSeen": false,
  "concurrency": 4,
  "maxScanSeconds": 900,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "mode": "search",
    "recordTypes": [
        "products"
    ],
    "searchQueries": [
        "brake discs"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/halfords-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 = {
    "mode": "search",
    "recordTypes": ["products"],
    "searchQueries": ["brake discs"],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/halfords-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 '{
  "mode": "search",
  "recordTypes": [
    "products"
  ],
  "searchQueries": [
    "brake discs"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/halfords-scraper --silent --output-dataset

```

## MCP server setup

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