# Drogasil Brazil Pharmacy, Health & Beauty Scraper (`abotapi/drogasil-com-br-scraper`) Actor

Scrape Drogasil (drogasil.com.br) medicines, health and beauty products by keyword, catalogue section or pasted link. Returns EAN, brand, price in BRL, discount, multi-buy price, stock, images, variants and the regulatory block. Incremental mode tracks daily changes.

- **URL**: https://apify.com/abotapi/drogasil-com-br-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 42.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 product results

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

## Drogasil Brazil Pharmacy, Health & Beauty Scraper

Scrape the full product catalogue of **drogasil.com.br**, one of Brazil's largest pharmacy
chains: medicines, vitamins and supplements, health devices, beauty, daily care, baby and pet.

Search by keyword, browse a whole catalogue section, or paste links. Every record comes back flat,
with the barcode, the current and pre-discount price in BRL, the multi-buy ("leve mais por menos")
offer, live stock, images, per-variant rows, and the full Brazilian pharmacy regulatory block.

***

### What you get

#### Always (listing fields, no extra reads)

| Field | Description |
|---|---|
| `productId`, `sku` | The store's own product code |
| `name`, `brand` | Product title and brand |
| `url` | Canonical product address (tracking parameters stripped) |
| `image`, `images` | Cover image and gallery |
| `price`, `currency` | Current price, always `BRL` |
| `packSize` | Pack size as the store states it (`10 Comprimidos`, `3g`, `100ml`) |
| `prescriptionRequired` | Whether a prescription is needed |
| `isGenericMedicine` | Generic (`genérico`) medicine flag |
| `isKit` | Bundled multi-product kit |
| `requiresRefrigeration` | Cold-chain product (`termolábil`) |
| `soldBy` | `drogasil` (the pharmacy's own stock) or `marketplace` (a partner seller) |
| `categories`, `categoryPath` | Category trail, as a list and as one string |
| `productGroup` | The store's own product grouping (`MEDICAMENTO`, `OTC`, `PERFUMARIA`, ...) |
| `pharmaceuticalForm` | Dosage form when the store publishes it on the card |
| `drugClassificationCode` | The store's own medicine classification code |
| `badges` | Promotional labels shown on the card |
| `variantCount`, `variantAttributes` | How many variants exist, and this one's option values |
| `isSponsored` | The row was a sponsored placement in a keyword search |
| `searchMode`, `scrapedAt` | Which route found the product, and when |

#### With **Fetch product details** on (one extra read per product, billed once)

| Field | Description |
|---|---|
| `ean` | Barcode / GTIN-13 |
| `originalPrice`, `discountPercent`, `onSale` | Pre-discount price and the reduction |
| `multiBuyUnitPrice`, `multiBuyMinQuantity` | The "leve mais por menos" offer: buy N or more, pay this per unit |
| `pixPrice`, `pixDiscountPercent` | The instant-payment (Pix) price and its extra discount |
| `installments` | Instalment plan rows (`count`, `amount`) |
| `stockQuantity`, `inStock` | Live stock the store reports for the product |
| `images` | The full media gallery, in the store's own order |
| `description`, `shortDescription`, `longDescription` | Product copy, flattened to plain text |
| `usageInstructions` | The store's detailed product description line |
| `activeIngredient` | Active ingredient (`princípio ativo`) |
| `dosage` | Strength, e.g. `1G`, `50MG` |
| `manufacturer` | Manufacturer (`fabricante`) when published |
| `healthMinistryRegistration` | The Brazilian health-ministry / ANVISA registration number (`registro MS`) |
| `prescriptionCategory`, `prescriptionStripeCode` | The prescription stripe (`tarja`) classification and its code |
| `prescriptionRequired` | Derived from the published stripe code |
| `controlledMedication` | Controlled-substance flag |
| `psychotropicListCode` | Psychotropic control-list code |
| `therapeuticClassCode`, `therapeuticClassName` | Therapeutic class (ATC-style code plus its name) |
| `packageInsertUrl`, `packageInsertPage` | The package insert (`bula`): the PDF and the store's own page |
| `weightKg` | Shipping weight |
| `sellerName`, `benefitProgramAvailable` | Marketplace seller name; whether a medicine-benefit programme applies |
| `breadcrumb` | The product page's own category trail |
| `variants` | One row per variant: `sku`, `name`, `attributes`, `price`, `stockQuantity`, `inStock` |

#### In incremental mode

`changeType` (`NEW` / `UPDATED` / `REAPPEARED` / `UNCHANGED` / `EXPIRED`), `changedFields`,
`firstSeenAt`, `lastSeenAt`.

***

### Two modes

#### Search mode

Give **keywords**, **catalogue sections**, or both. Each keyword and each section is collected
separately, up to `maxItems` products and `maxPages` result pages each.

```json
{
  "mode": "search",
  "queries": ["dipirona"],
  "categories": ["medicamentos"],
  "maxItems": 50,
  "fetchDetails": true
}
```

**Keyword searches and section browsing read the store through different doors.** Catalogue
sections and pasted links are read from the store's pages; a keyword search is read from the
store's own search interface (see *Connection* below for why). Both return the same product rows,
filters and totals, and both are walked forward page by page in the same way.

#### URL mode

Paste any mix of product pages, catalogue section pages and search result pages. Each entry is
recognised by the page's own type, so you never have to say which is which. A link that already
names a page number (`?p=3`) is honoured, so you get results from page 3 onwards and not from
page 1.

```json
{
  "mode": "url",
  "urls": [
    "https://www.drogasil.com.br/dipirona-genericos-1g-com-10-comprimidos.html",
    "https://www.drogasil.com.br/beleza/maquiagem/batom.html?p=2"
  ],
  "fetchDetails": true
}
```

***

### Filters and sorting

Everything in the filter section applies in **both** modes: it narrows a keyword search, a browsed
section, and a section or search link you pasted.

| Input | Applied by | Notes |
|---|---|---|
| `brands` | the store | Spell the brand exactly as the store's own brand filter does |
| `minPrice` / `maxPrice` | the store | In BRL |
| `soldBy` | the store | Pharmacy's own stock, or marketplace partners |
| `excludeKits` | the store | Drop bundled kits |
| `sortBy` | the store | Relevance, price low to high, price high to low |
| `prescriptionFilter` | this actor | The store publishes the prescription class but offers no filter for it |
| `inStockOnly` | this actor | Live stock is only published on the product page, so this needs `fetchDetails` |

The two actor-applied filters are checked against the products that come back, so a run using them
may return fewer than `maxItems`.

If you paste a link that already carries its own filters, they are **kept** and the inputs above are
added on top.

***

### Recurring monitoring

Two separate features, both in the **Resume & recurring updates** section:

- **`resumeFromRunId`** continues ONE interrupted run. Paste the previous run or dataset ID and the
  products it already collected are skipped, and not billed again.
- **`incrementalMode`** is for a schedule. The actor remembers the previous run of the same search
  itself. The first run returns everything as `NEW`; later runs return only `NEW`, `UPDATED` and
  `REAPPEARED`. `emitUnchanged` and `emitExpired` are off by default because they return, and bill,
  extra rows.

State is kept separately per search, filter set and detail setting, so two different searches never
share a baseline. Set `stateKey` to name a campaign, or to deliberately share one.

`scrapedAt` is the only field excluded from change detection. Every price field, and live stock, are
included: a restock, a sell-out or a new multi-buy offer is a real change and is reported as
`UPDATED` with the field named in `changedFields`.

***

### What you are charged for

- **Product result** for each product returned.
- **Detail enrichment**, charged once per product returned when `fetchDetails` is on. It is never
  charged for a product that incremental mode suppressed, and never for a product whose page could
  not be read.
- **Actor start**, the platform's standard start event.

Turn `fetchDetails` off for a listing-only run: it is one read per result page instead of one read
per product, and the surcharge is not charged at all.

***

### Send results into your apps (MCP connectors)

Optionally pipe results into the apps you already use, as well as into the dataset. Authorize a
connector under Apify, Settings, API & Integrations, then select it in `mcpConnectors`. Notion,
Linear, Airtable and Apify are offered in the picker, and any other Model Context Protocol server
you have authorized can be added by its URL.

For Notion, also set `notionParentPageUrl` and each product becomes a page under it. The other
connectors get a best-effort write, or a digest when the connector exposes no suitable write tool.

Each connector receives a condensed, human-readable summary per product: the product name plus the
key fields flattened to plain text, with nested objects collapsed to their main value and long lists
trimmed. The complete record always stays in the Apify dataset. `maxNotifyListings` caps how many
products are written per connector, defaults to 50, and never affects the dataset. Leaving
`mcpConnectors` empty skips this entirely, and a connector that fails never fails the run.

***

### Notes on this store, measured live

**Brazil only, and there is deliberately no country input.** The store serves one market from one
catalogue: every page declares `lang="pt-BR"`, every price is in `BRL`, there are no `hreflang`
alternates and no locale or country switcher anywhere in the site. A country input would be a knob
that changes nothing, so there is none. The sibling site `drogaraia.com.br` is a separate storefront
and is not in scope for this actor.

**Reviews are not available.** This is a real finding about the store, not an omission. The store
renders no review data on any server-rendered page: there is no rating, no review count and no
review body in the product payload, and no `aggregateRating` in its structured data. The product
page has an "Avaliações" (reviews) anchor, but the section behind it is filled in by a third-party
widget entirely in the browser, and that widget is switched off for the two product groups that
matter most here, medicines and over-the-counter medicines. Re-checked on 2026-08-28: the widget's
own endpoint for this store also answers every request with an empty body, so even a run that
rendered the page in a browser would have nothing to read. There is therefore no `fetchReviews`
input, because it could only ever return nothing.

**Store pickup versus delivery is not published per product.** The store decides fulfilment at
checkout from your postcode, so no product page states "available for pickup". What the store does
publish, and what this actor returns, is `soldBy` (its own stock, which its branches fulfil, versus
a marketplace partner that ships the order itself), `requiresRefrigeration` for cold-chain items,
and the controlled-medication flags, which are the constraints that actually change how an order can
be fulfilled.

**Prices are national.** The store renders one national price per product on its public pages;
branch-level pricing is only resolved after a postcode is entered in a session, so this actor
reports the public price.

**Connection.** The store turns away connections it does not recognise, so the run reads it through
a connection built for exactly that kind of store, set up for you out of the box: you do not need
to configure anything in the Connection section, and leaving Apify Proxy off entirely is likely to
get the run refused. Any pool you select there is still honoured: it is tried on its own first,
and it stays available as a fallback for the whole run. If the store declines a request the actor
retries a bounded number of times and then reports the failure, rather than returning an empty
result as if the search had simply found nothing.

**Keyword search goes through the store's own search interface.** Since 2026-09-04 the store's
search page itself refuses automated readers on every connection (while catalogue sections, product
pages and pasted links keep being served). A keyword search is therefore read from the same JSON
interface the store's own website posts to when a shopper types a keyword; it returns the same
products, filters, totals and page counts as the page did. Nothing changes in the input or the
output.

A run that reads nothing at all tells you **which** of the three things went wrong, because each
one needs a different next step from you:

| what the run reports | what happened | what to do |
| --- | --- | --- |
| "Enable Apify Proxy in the Connection section" | no connection was set up, so nothing was ever sent | turn Apify Proxy on, or supply your own exits |
| "the connection selected for this run was refused before any request left it" | a connection was set up, but your account is not allowed to use the option that was picked, so the store never saw the request | pick another option in the Connection section, or one your plan includes |
| "Apify Proxy was already enabled for this run, so this is the store blocking this specific request" | the connection worked and the store itself turned the request away | retry later, or use a different route (browse by `categories`, or paste a link) |

The second and third cases used to be reported as the first one, which sent people off to enable a
connection they already had.

**Result counts.** The store's own declared page ceiling is not the item count divided by the page
size: a 2,543 product section declares 42 pages at 48 rows a page, and 21 pages when the same
section is sorted by price. Both of the store's own signals are honoured, whichever ends the results
first, and an empty page ends them too. So `maxPages` is a ceiling, not a promise: a section can
finish earlier because the store says it has.

***

### Local development

```bash
python3.12 -m venv .venv
.venv/bin/pip install -r requirements.txt
.venv/bin/python -m pytest tests -q
apify run --purge
```

### Verification

Re-verified against the live source on 2026-08-31 (build 1.1): the batom catalogue section reports 2,547 products server-side (2,543 at the previous audit, live churn); the Ruby Rose brand facet narrows it to 237 exactly as the site's own facet island declares, a 10 to 20 BRL price band narrows it to 245, the "sold by Drogasil" facet to 104, and dropping kits on the vitaminas section narrows 52,716 to 52,591. An unknown brand returns zero rows rather than silently ignoring the filter. The keyword route composes with the filters ("dipirona" reports 155 results; brand facets read off the search surface narrow it to 2 or 3 all-brand rows), and the price sorts reorder server-side (first row 6.22 BRL ascending vs 27.15 unsorted vs 4,182 descending). Pasted links resolve: a product page parses with its full regulatory block, and a section link carrying ?p=2 continues from page 2.

# Actor input Schema

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

Choose 'search' to search the catalogue by keyword or browse a catalogue section, or 'url' to scrape pasted links: product pages, catalogue section pages and search result pages are all accepted.

## `queries` (type: `array`):

Only used when mode = search, ignored in url mode. One or more keywords, for example dipirona, vitamina c or shampoo. Leave empty and pick a Catalogue section below to browse a whole section instead.

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

Only used when mode = search, ignored in url mode. Browse whole catalogue sections. Each selected section is walked on its own, so selecting several returns products from all of them. Combine with keywords to run both.

## `urls` (type: `array`):

Only used when mode = url, ignored in search mode. Mix freely: product pages such as https://www.drogasil.com.br/<product-slug>.html , section pages such as https://www.drogasil.com.br/beleza/maquiagem/batom.html , or search pages such as https://www.drogasil.com.br/search?w=dipirona .

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

Optional. Keep only products of these brands, spelled exactly as the store spells them on its own brand filter (for example Neosaldina, Vult, Nivea, Ruby Rose). Selecting several returns products from any of them. Leave empty for all brands.

## `minPrice` (type: `integer`):

Optional. Keep only products priced at or above this amount, in Brazilian reais. Applied by the store itself, so it narrows the result count at the source.

## `maxPrice` (type: `integer`):

Optional. Keep only products priced at or below this amount, in Brazilian reais. Applied by the store itself, so it narrows the result count at the source.

## `soldBy` (type: `string`):

Optional. Keep only products sold by the pharmacy's own stock, or only products sold by its marketplace partners. The pharmacy's own stock is what the store can fulfil from its own branches; a marketplace partner ships the order itself.

## `excludeKits` (type: `boolean`):

Optional. Drop bundled kits and keep only single products. Applied by the store itself, so it narrows the result count at the source.

## `prescriptionFilter` (type: `string`):

Optional. Keep only prescription medicines, or only products that need no prescription. The store publishes the prescription stripe classification on every product but does not offer it as a filter, so this is applied to the products that come back and a run may therefore return fewer than Max products.

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

Optional. Keep only products the store currently reports live stock for. Requires Fetch product details, because live stock is only published on the product page.

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

The order the store returns results in. Relevance is the store's own default ordering.

## `fetchDetails` (type: `boolean`):

Read each product's own page to add the barcode (EAN), the pre-discount price and discount, the multi-buy 'leve mais por menos' price per unit and its qualifying quantity, the Pix and instalment prices, live stock, the full image gallery, the description, the per-variant rows with their own price and stock, and the regulatory block: active ingredient, dosage, manufacturer, health-ministry registration number, prescription stripe classification, controlled-substance and psychotropic codes, therapeutic class and the package-insert link. Turn off for a faster, cheaper run that returns listing fields only.

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

Maximum number of products to return across the whole run. This is the run's cap. Use 0 for unlimited.

## `maxPages` (type: `integer`):

Maximum number of result pages read per keyword, catalogue section or link. 0 means no limit, which is the default: the run then stops only at Max products, at the end of the results, or when a page returns nothing new.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large catalogue pull without returning or charging for products already collected there. Use this after an interrupted run. For recurring daily monitoring of the same search, use Incremental mode below instead.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching product as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED products. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed). State is kept separately for each search, filter and detail setup; use State key to name or deliberately share a monitoring campaign. To continue one specific interrupted run instead, use Resume from a previous run above.

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

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the search, filters and detail settings, so different searches never mix state with each other.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return products that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want the full snapshot every run.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return products that were present in a previous run but are no longer found, marked EXPIRED. Only produced once a run has fully scanned the tracked search, so never when Max products capped it or when Resume was used. This returns, and bills, extra synthetic rows, so leave it off unless you need expiry tracking.

## `proxy` (type: `object`):

Leave the default on unless you have a reason to change it. The run reads the store through a connection built for stores that turn automated readers away, set up for you; any pool you select here is still honoured, tried on its own first and kept as the fallback, and the run reports in its log if the store starts refusing.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "dipirona"
  ],
  "urls": [
    "https://www.drogasil.com.br/dipirona-genericos-1g-com-10-comprimidos.html",
    "https://www.drogasil.com.br/beleza/maquiagem/batom.html"
  ],
  "soldBy": "any",
  "excludeKits": false,
  "prescriptionFilter": "any",
  "inStockOnly": false,
  "sortBy": "relevance",
  "fetchDetails": true,
  "maxItems": 20,
  "maxPages": 0,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  },
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "search",
    "queries": [
        "dipirona"
    ],
    "urls": [
        "https://www.drogasil.com.br/dipirona-genericos-1g-com-10-comprimidos.html",
        "https://www.drogasil.com.br/beleza/maquiagem/batom.html"
    ],
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/drogasil-com-br-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",
    "queries": ["dipirona"],
    "urls": [
        "https://www.drogasil.com.br/dipirona-genericos-1g-com-10-comprimidos.html",
        "https://www.drogasil.com.br/beleza/maquiagem/batom.html",
    ],
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/drogasil-com-br-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",
  "queries": [
    "dipirona"
  ],
  "urls": [
    "https://www.drogasil.com.br/dipirona-genericos-1g-com-10-comprimidos.html",
    "https://www.drogasil.com.br/beleza/maquiagem/batom.html"
  ],
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/drogasil-com-br-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/drogasil-com-br-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/W4Rzt1ErUcXJCJ3Vo/builds/25zQVAbm07lehCaSA/openapi.json