# Zillow to Airbnb Investment Calculator & STR Analysis (`zapticx/zillow-airbnb-str-calculator`) Actor

Analyze a Zillow listing as a short-term rental: comparable Airbnb rates, financing, and expenses projected into cap rate, cash flow, and break-even occupancy.

- **URL**: https://apify.com/zapticx/zillow-airbnb-str-calculator.md
- **Developed by:** [Zapticx](https://apify.com/zapticx) (community)
- **Categories:** Real estate, Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 77.8% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $150.00 / 1,000 analysis completes

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?

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

## Zillow to Airbnb Investment Calculator & STR Analysis

#### 🏡 Found a Zillow property. Could it actually work as an Airbnb?

Normally that means opening a spreadsheet, hunting down Airbnb comps by hand, guessing at a
mortgage payment, and building your own cap-rate formula before you even know if the property is
worth a second look. This Actor answers the question in one run.

**Zillow property → Airbnb comparables → STR investment analysis**

Give it a Zillow listing URL (or just a city/ZIP if you haven't found one yet) and get back:

- **Purchase price** → observed from Zillow
- **Airbnb nightly rates** → observed from comparable listings nearby
- **Financing + expenses** → your explicit, adjustable assumptions
- **Cap rate · cash flow · cash-on-cash · DSCR** → calculated
- **Break-even occupancy** → calculated
- **Conservative / Base / Optimistic** → three scenarios, side by side

No spreadsheets, no manually cross-referencing Airbnb listings, no guessing at a mortgage
payment — just the numbers, each one clearly labeled by where it actually came from.

> **Worth 30 seconds:** fill in **Annual insurance**. Zillow never publishes it, and rather than
> invent a number this Actor returns cap rate, cash flow, and break-even occupancy as `null` when
> the cost basis is incomplete. Provide it and you get the full analysis. See
> [When the evidence isn't strong enough](#when-the-evidence-isnt-strong-enough).

*Independent tool — not affiliated with, endorsed by, or sponsored by Zillow Group, Inc. or
Airbnb, Inc. "Zillow" and "Zestimate" are trademarks of Zillow, Inc.; "Airbnb" is a trademark of
Airbnb, Inc.*

### Observed data, your assumptions, and calculated projections — kept strictly separate

This is the part that makes the numbers trustworthy: this Actor never blurs observed fact into a
projection. Every output record is four separated blocks — what Zillow actually reported about
the property, what Airbnb actually reported about comparable nightly rates nearby, exactly which
assumptions drove the math (and where each one came from — Zillow's own data, you, or genuinely
unknown), and the calculated projections built on top of them. The projections are always clearly
labeled as estimates derived from your assumptions — never presented as facts, market predictions,
or guarantees of future occupancy, revenue, or returns.

This Actor orchestrates this account's own `zillow-market-intelligence` and
`airbnb-market-intelligence` Actors rather than re-scraping either site.

### What this Actor does

Give it a single Zillow listing URL, and it fetches that exact property, searches for comparable
Airbnb nightly rates in the same market (bedroom-matched when possible), and runs the numbers:
loan amount, monthly mortgage payment, gross revenue, operating expenses, NOI, cash flow, cap
rate, cash-on-cash return, DSCR, and break-even occupancy — for a conservative (P25 nightly rate),
base (median), and optimistic (P75) scenario.

No listing URL yet? Give it a `location` instead (city, state, or ZIP) and it deterministically
selects one representative active listing from that market — never an arbitrary first result, and
never chosen based on projected return (see [How the representative property is
selected](#how-the-representative-property-is-selected)).

### Why use it?

Most STR calculators either require you to manually gather comps, or quietly bake in national
default assumptions for property tax and insurance that don't apply to your market. This Actor
does neither:

- Property tax uses Zillow's own reported rate for *that* property when available — never a
  national or state average.
- Insurance has no default anywhere. Zillow doesn't publish it, so it's either what you enter or
  explicitly `unknown` — never a guessed number disguised as a real one.
- Occupancy is always labeled as your own adjustable assumption, never presented as a market
  estimate.
- When the Airbnb comparable evidence is too thin to support a credible nightly-rate estimate,
  revenue-driven numbers come back `null` with a reason — not a number that merely *looks*
  precise.

### Who is it for?

Individual STR buyers evaluating a specific property, real estate agents building investor-ready
numbers for a listing, and analysts who want a defensible, source-separated model they can audit
line by line rather than a black-box "cash flow" figure.

### Input

#### Property (choose exactly one)

| Field | Required | Description |
| --- | --- | --- |
| `zillowListingUrl` | One property input | A single `zillow.com/homedetails/...` URL. The primary, serious-investment workflow — always takes precedence and skips property selection entirely. |
| `location` | One property input | City, state, or ZIP. Resolves one currently active listing in that market — see [property selection](#how-the-representative-property-is-selected). |

#### Financing

| Field | Default | Description |
| --- | --- | --- |
| `downPaymentPercent` | 20 | Percent of price paid as down payment. |
| `interestRatePercent` | 7.0 | Illustrative default — check current rates and adjust. |
| `loanTermYears` | 30 | Amortization period. |
| `closingCostsPercent` | 2.5 | Percent of price added to total cash invested. |
| `furnishingBudget` | 0 | One-time STR setup cost, added to total cash invested. |

#### Operating expenses (no hidden defaults)

| Field | Default | Description |
| --- | --- | --- |
| `propertyTaxAnnual` | *(none)* | Leave blank to use Zillow's own reported rate for this listing when available. Otherwise marked `unknown`, never guessed. |
| `insuranceAnnual` | *(none)* | No default anywhere — Zillow doesn't publish this. Leave blank to mark `unknown`. |
| `hoaMonthlyOverride` | *(none)* | Leave blank to use Zillow's own reported HOA fee when available. On a condo, townhouse, or apartment an unknown HOA is treated as missing data (see below), so set it here if Zillow doesn't report one. |
| `managementFeePercent` | 15 | Illustrative default for full-service management; set to 0 if self-managing. |
| `maintenanceReservePercent` | 8 | Illustrative reserve for repairs/upkeep. |
| `platformFeePercent` | 3 | Booking platform fee — adjustable, not a universal constant. |
| `utilitiesAnnual` | 0 | STR hosts typically cover utilities, unlike long-term rentals. |

#### Occupancy scenarios (explicit assumptions, never a market prediction)

| Field | Default | Paired with |
| --- | --- | --- |
| `conservativeOccupancyPercent` | 40 | Airbnb comparable set's 25th-percentile nightly rate |
| `baseOccupancyPercent` | 60 | Median nightly rate |
| `optimisticOccupancyPercent` | 80 | 75th-percentile nightly rate |

#### Comparable set

| Field | Default | Description |
| --- | --- | --- |
| `maxComparables` | 20 | Airbnb comparables to collect, 8–100. Larger samples cost more (each is billed by the Airbnb Actor) but improve confidence. |

#### Example inputs

##### A specific property (the primary workflow)

```json
{
  "zillowListingUrl": "https://www.zillow.com/homedetails/247652439_zpid/",
  "insuranceAnnual": 12000
}
```

##### No listing yet — analyze a representative property in a market

```json
{
  "location": "Miami Beach, FL"
}
```

##### Adjusting the financing and occupancy assumptions

```json
{
  "zillowListingUrl": "https://www.zillow.com/homedetails/46291510_zpid/",
  "insuranceAnnual": 2200,
  "downPaymentPercent": 40,
  "baseOccupancyPercent": 55
}
```

### Output

One `str_analysis` record per run in the default dataset, always these five top-level parts:

- **`propertySelection`** — how the analyzed listing was chosen: `user_provided_url` (you gave
  the exact listing) or `representative_location_listing` (deterministically picked from a
  location search), plus a plain-English explanation and the market Zillow actually searched.
- **`observedZillow`** — straight from the property: price, size, beds/baths, Zestimate, Zillow's
  own reported property-tax rate and HOA fee when published. Nothing computed except
  `priceVsZestimatePercent`, a direct comparison of two observed values.
- **`observedAirbnbComparables`** — straight from the Airbnb comparable search: sample size,
  confidence, and P25/median/P75 nightly rates. Returned in full even when the sample is too weak
  to drive a projection.
- **`assumptions`** — every financing/expense input actually used, with a `Source` field
  (`user_provided` / `observed_from_zillow` / `unknown`) for property tax, insurance, and HOA.
- **`projections`** — the calculated three-scenario output, with a standing disclaimer and
  explicit completeness signals (see below). Never presented as fact.

#### Complete example (real run, abbreviated)

```json
{
  "recordType": "str_analysis",
  "propertySelection": {
    "mode": "user_provided_url",
    "explanation": "Analyzing the exact listing URL provided. No property selection was performed."
  },
  "observedZillow": {
    "zpid": "46291510",
    "addressCity": "Kissimmee",
    "addressState": "FL",
    "price": 350000,
    "bedrooms": 3,
    "propertyTaxRatePercent": 0.85,
    "monthlyHoaFee": 210
  },
  "observedAirbnbComparables": {
    "comparableSampleSize": 26,
    "confidence": "medium",
    "medianNightlyPrice": 145.75,
    "priceP25": 118.5,
    "priceP75": 187.25
  },
  "assumptions": {
    "downPaymentPercent": 20,
    "propertyTaxSource": "observed_from_zillow",
    "insuranceAnnual": 2200,
    "insuranceSource": "user_provided",
    "hoaSource": "observed_from_zillow"
  },
  "projections": {
    "projectionCompleteness": "complete",
    "scenarios": [
      {
        "scenario": "base",
        "nightlyRate": 145.75,
        "occupancyPercent": 60,
        "grossAnnualRevenue": 31919.25,
        "noiAnnual": 16205.25,
        "annualCashFlow": 5028.16,
        "capRatePercent": 4.63,
        "cashOnCashReturnPercent": 2.3,
        "dscr": 1.45,
        "breakEvenOccupancyPercent": 47.23,
        "breakEvenAchievable": true,
        "suppressedReasons": []
      }
    ],
    "disclaimer": "All figures in this block are calculated estimates derived from the assumptions above, not observed facts, market predictions, or guarantees of future performance. Occupancy, revenue, cash flow, cap rate, cash-on-cash return, and break-even occupancy are all projections, not promises."
  }
}
```

#### When the evidence isn't strong enough

If the Airbnb comparable sample's confidence is `low` or `insufficient`, every revenue-dependent
field comes back `null` with a reason — `observedZillow`, `observedAirbnbComparables` (including
the real sample size and confidence), and `assumptions` are still returned in full:

```json
{
  "scenario": "base",
  "nightlyRate": null,
  "grossAnnualRevenue": null,
  "noiAnnual": null,
  "capRatePercent": null,
  "breakEvenOccupancyPercent": null,
  "breakEvenAchievable": null,
  "suppressedReasons": ["insufficient_airbnb_comparables"]
}
```

**HOA is judged by property type.** On a condo, townhouse, or apartment — where a monthly fee is
effectively universal — an unknown HOA counts as genuinely missing data and suppresses the
NOI family, because silently omitting a few hundred dollars a month would overstate returns. On a
detached single-family home, no reported HOA usually means no HOA, so the projection still
completes and simply lists `hoa` under `excludedExpenseCategories`. Supplying
`hoaMonthlyOverride` (including an explicit `0`) always resolves it.

The same applies, independently, when property tax or insurance is `unknown`: revenue stays
visible (it doesn't depend on expenses) but every field that combines revenue with an incomplete
cost basis — NOI, cash flow, cap rate, cash-on-cash, DSCR, break-even — is suppressed rather than
silently computed on known costs only. `projections.missingAssumptions` and
`projections.projectionCompleteness` (`complete` / `partial_expenses` / `revenue_unavailable`)
summarize this at a glance; `scenario.suppressedReasons` explains each one.

### Understanding the numbers

- **Break-even occupancy** is never clamped to 100% — a deal that can't work even at full
  occupancy still shows its real value (e.g. `354%`), paired with `breakEvenAchievable: false` so
  it's machine-readable without misreading an oversized percentage as a typo.
- **Cash flow, cash-on-cash return, and cap rate** are never floored at zero — a losing deal shows
  a real negative number.
- **Cap rate** excludes debt service (NOI ÷ price); it can stay positive even when cash flow (which
  includes the mortgage payment) is negative.
- **DSCR** (debt service coverage ratio) is NOI ÷ annual debt service — below 1.0 means the
  property's own operations don't cover the mortgage payment.

### How the representative property is selected

When you provide `location` instead of a specific listing, the Actor fetches a sample of ~20
active Zillow listings for that market, filters to ones with enough data to analyze (a real
price, bedroom count, and listing URL), then picks the one closest to the sample's median price
among listings sharing the sample's most common bedroom count — ties broken deterministically. It
never considers projected revenue, occupancy, or any other return signal, and it is never
presented as a recommendation.

Before doing any of this, the Actor cross-checks the requested `location` against the addresses
Zillow's search actually returned. If they don't plausibly match — which can happen because
Zillow doesn't error on an unrecognized location; it can silently substitute a nearby fallback
region and still return real-looking listings from there — the run fails with a clear message
rather than silently analyzing the wrong market.

### Data quality and limitations

- **V1 is single-property analysis only.** No batch mode or cross-location ranking yet.
- **Insurance has no default and is never inferred** — Zillow does not publish it for any
  listing. Provide `insuranceAnnual` for a complete cost basis, or the NOI-family metrics stay
  `null`.
- **Occupancy percentages are your own assumption**, not a market forecast, regardless of how
  they're labeled elsewhere in this description.
- **The Airbnb comparable set is a live sample**, not a certified market report — its size and
  confidence are always disclosed alongside the rates.
- **A representative-location analysis is a reference point, not a recommendation** — for a real
  purchase decision, use `zillowListingUrl` with the exact property.
- **This Actor performs no new scraping of its own** — it orchestrates this account's Zillow and
  Airbnb Actors and does the financial math; data quality limitations of those Actors (documented
  in their own READMEs) apply here too.

### Integrations

Standard Apify dataset output — export to JSON/CSV/Excel, or feed it into Make, n8n, Zapier,
Google Sheets, Airtable, webhooks, or a custom workflow.

### Performance

Measured directly on the Apify platform (256MB, default settings):

- **Location-only run:** ~35–40 seconds end to end (one Zillow search call, one Zillow
  target-listing call, one Airbnb comparable search), ~45–65MB peak memory.
- **Direct-URL run:** ~25–30 seconds (skips the Zillow search call), similar memory.
- **A target listing with no usable price** (off-market/unpriced) fails in ~16 seconds, before
  any Airbnb comparable search is spent on it.
- Zero retries and no proxy traffic across every run measured in production testing.

### Pricing

Complete analyses cost **$0.15** (`analysis_complete`) and insufficient-evidence analyses cost
**$0.05** (`analysis_insufficient`), plus the underlying Zillow and Airbnb Actor charges used to
retrieve property and comparable data. Failed runs are not charged by this Actor — this only
fires once a full analysis record has actually been produced.

Those child-Actor charges run under and bill to *your* account directly, at their own published
per-event prices — this Actor calls this account's `zillow-market-intelligence` and
`airbnb-market-intelligence` Actors internally, and Apify's platform model bills nested Actor
calls to whoever's account is running the calling Actor, not to us. A typical direct-URL analysis
with 25 Airbnb comparables is approximately **$0.20 total** at current child-Actor pricing. Larger
`maxComparables` values increase the Airbnb-side portion of that total.

### Troubleshooting

**Run fails with "does not appear to match the market Zillow actually searched."** Your
`location` wasn't recognized by Zillow and it silently substituted a nearby region — try a more
specific city/state, or a ZIP code.

**Run fails with "no usable price."** The target listing is off-market, an unpriced lot/auction
listing, or otherwise lacks a price Zillow can report — this fails fast, before spending an
Airbnb comparable search on it.

**Every scenario's revenue fields are `null`.** Check `observedAirbnbComparables.confidence` — if
it's `low` or `insufficient`, the comparable sample wasn't strong enough to support a defensible
nightly-rate estimate. Try a larger `maxComparables`, or expect this for very unusual properties
(extreme bedroom counts, remote markets) where comparable Airbnb listings are genuinely scarce.

**NOI, cash flow, and cap rate are `null` even though revenue shows a number.** Check
`projections.missingAssumptions` — property tax or insurance is `unknown`. Provide
`insuranceAnnual` (always required — Zillow never reports it) and/or `propertyTaxAnnual` if
Zillow doesn't publish a rate for this listing.

### FAQ

#### Does this recommend properties or predict returns?

No. Property selection (when using `location`) is deterministic and based only on price and
bedroom count — never on projected return. Projections are clearly labeled estimates based on
your stated assumptions, never facts, market predictions, or guarantees.

#### Why is insurance never filled in automatically?

Zillow doesn't publish insurance costs for any listing, and insurance varies enormously by
location, coverage, and whether a policy allows short-term rental use. A national or regional
average would materially mislead a specific property's numbers, so this Actor never guesses it.

#### Can I run this for multiple properties or rank locations?

Not in V1 — that's planned as a separate batch/ranking mode. This version is single-property
analysis only.

#### What happens if I give both a URL and a location?

The input schema requires exactly one — the run is rejected with a clear validation error before
either Actor is called.

# Actor input Schema

## `zillowListingUrl` (type: `string`):

A single zillow.com/homedetails/... listing URL to analyze. Provide exactly one of zillowListingUrl or location.

## `location` (type: `string`):

City, state, or ZIP — if you don't have a specific listing URL yet, the Actor resolves one currently active Zillow listing in this area and analyzes it. Provide exactly one of zillowListingUrl or location.

## `downPaymentPercent` (type: `integer`):

Percent of purchase price paid as down payment.

## `interestRatePercent` (type: `number`):

Illustrative default — mortgage rates change; check current rates and adjust.

## `loanTermYears` (type: `integer`):

Amortization period used to calculate the monthly mortgage payment.

## `closingCostsPercent` (type: `number`):

Illustrative default for total cash invested. Adjust to your market/lender.

## `furnishingBudget` (type: `integer`):

One-time cost to furnish and set up the property for short-term rental. Not estimated — enter your own budget if you want it included in total cash invested.

## `propertyTaxAnnual` (type: `integer`):

Leave blank to use Zillow's own reported tax rate for this listing when available. Property taxes vary enormously by state/county — there is no national default here. If Zillow doesn't report one and you leave this blank, property tax is marked unknown, not guessed.

## `insuranceAnnual` (type: `integer`):

No default — insurance cost depends on location, coverage, and STR-specific policy requirements. Leave blank to mark unknown rather than guess.

## `hoaMonthlyOverride` (type: `integer`):

Leave blank to use Zillow's own reported HOA fee for this listing when available.

## `managementFeePercent` (type: `number`):

Illustrative default for full-service STR management. Adjust to your actual arrangement, or set to 0 if self-managing.

## `maintenanceReservePercent` (type: `number`):

Illustrative default reserve for repairs and upkeep. Adjust to the property's age/condition.

## `platformFeePercent` (type: `number`):

Illustrative default (Airbnb's typical host service fee). Adjust to your actual platform/fee tier — not a universal constant.

## `utilitiesAnnual` (type: `integer`):

STR hosts typically cover utilities (power, water, internet), unlike long-term rentals. Defaults to 0, which assumes no utility cost — enter your own annual estimate to include it in the expense basis.

## `conservativeOccupancyPercent` (type: `integer`):

An illustrative, user-adjustable assumption — not a market occupancy estimate or prediction. Paired with the Airbnb comparable set's 25th-percentile nightly rate.

## `baseOccupancyPercent` (type: `integer`):

An illustrative, user-adjustable assumption — not a market occupancy estimate or prediction. Paired with the Airbnb comparable set's median nightly rate.

## `optimisticOccupancyPercent` (type: `integer`):

An illustrative, user-adjustable assumption — not a market occupancy estimate or prediction. Paired with the Airbnb comparable set's 75th-percentile nightly rate.

## `maxComparables` (type: `integer`):

How many nearby Airbnb listings to collect for the comparable nightly-rate set. Larger samples cost more (each comparable is billed by the Airbnb Actor) but improve confidence.

## Actor input object example

```json
{
  "location": "Miami Beach, FL",
  "downPaymentPercent": 20,
  "interestRatePercent": 7,
  "loanTermYears": 30,
  "closingCostsPercent": 2.5,
  "furnishingBudget": 0,
  "managementFeePercent": 15,
  "maintenanceReservePercent": 8,
  "platformFeePercent": 3,
  "utilitiesAnnual": 0,
  "conservativeOccupancyPercent": 40,
  "baseOccupancyPercent": 60,
  "optimisticOccupancyPercent": 80,
  "maxComparables": 20
}
```

# Actor output Schema

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

The default dataset — one str\_analysis record.

# 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 = {
    "location": "Miami Beach, FL"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zapticx/zillow-airbnb-str-calculator").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 = { "location": "Miami Beach, FL" }

# Run the Actor and wait for it to finish
run = client.actor("zapticx/zillow-airbnb-str-calculator").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 '{
  "location": "Miami Beach, FL"
}' |
apify call zapticx/zillow-airbnb-str-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zapticx/zillow-airbnb-str-calculator"
        }
    }
}

```

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/3ivyI4HquugY5Wchi/builds/FFk8qkiDlFE5O9fqU/openapi.json