# Google Maps Reviews Scraper & API — Ratings, Photos, Replies (`gauravlabs/google-maps-reviews-api`) Actor

Scrape Google Maps reviews from business URLs or Place IDs. Extract review text, ratings, dates, photos and owner replies. Export CSV, Excel or JSON, or run via API. No Google login required. Paid plans: $0.30/1,000 reviews; Free: $2/1,000. Filtered scans cost extra.

- **URL**: https://apify.com/gauravlabs/google-maps-reviews-api.md
- **Developed by:** [Gaurav Kumar Choudhary](https://apify.com/gauravlabs) (community)
- **Categories:** SEO tools, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 delivered reviews

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?

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

## Google Maps Reviews Scraper & API — Ratings, Photos, Replies

Scrape Google Maps reviews from public business URLs or Place IDs and export review text, star ratings, dates, photos and available owner replies to CSV, Excel or JSON. Use the simple input form without coding, or integrate the Google Maps reviews API into your application. No Google login or cookies required.

**Start with 20 reviews:** open [the input form](https://apify.com/gauravlabs/google-maps-reviews-api/input-schema), replace the sample business URL, set **Maximum reviews for each business** to **20**, and click **Start**. For an ordinary unfiltered run, 20 delivered reviews cost **$0.04 on Free** or **$0.006 on a paid Apify plan**, with no startup fee.

### What makes this review scraper useful?

- **For business teams:** paste Maps links and download a spreadsheet. No separate data-service subscription or key to configure.
- **For developers:** use Place IDs, data IDs or CIDs, structured dataset rows and the Apify REST API. Continuation tokens are available when a full page has been delivered.
- **For reputation monitoring:** choose newest reviews, date or rating filters, and available owner replies. Filtered requests have an additional attempt fee disclosed below.
- **For controlled spending:** set review, request, time and filtered-scan limits. Completed results are retained if collection stops early; duplicate review IDs are skipped within a run.

Built for customer-feedback reporting, local SEO workflows and multi-location review analysis. It collects data for your analysis; it does not generate sentiment scores or improve a business's Google ranking automatically.

### Pricing — understand the total before starting

#### Review pricing by Apify subscription

| Your Apify plan | Per delivered review | Per 1,000 delivered reviews |
| --- | --- | --- |
| Free | $0.002 | **$2.00** |
| Any paid plan | $0.0003 | **$0.30** |

Apify automatically selects the price from your subscription, not an editable input. Free-plan accounts can use available Apify credits; there is no separate zero-charge 1,000-review allowance or lifetime quota. Customers do not need an additional service token.

#### Additional fees and spending limits — all plans

- **Filtered API attempt:** an additional **$0.002 per attempt** when using keyword, topic, date, star-rating, text-only, owner-reply-only or skip-review-ID filters. This is charged **before each API attempt**, including retries, empty/failed requests and CID-resolution calls in filtered runs. It is not a guarantee of matching reviews.
- **No startup fee.** No filtered-scan surcharge for ordinary unfiltered collection. Choosing sort, language, reviewer details or image inclusion alone does not activate it. Error rows are not review results and do not incur review-result events.
- Default **Maximum filtered-scan charges** is $0.05 (25 attempts). This excludes review charges; use Apify's overall spending limit too. Filtered API timeouts are capped at 30 seconds. Completed results are preserved when limits stop collection.

Examples: 1,000 ordinary reviews cost **$2 on Free** or **$0.30 on a paid plan**. A filtered run with 50 API attempts and 1,000 delivered matches costs $0.10 plus the review fee: **$2.10 on Free** or **$0.40 on paid** (increase the scan cap explicitly to permit 50 attempts). Two filtered attempts returning two matching reviews cost **$0.008 on Free** or **$0.0046 on paid**. Filtered calls returning zero matches still incur the attempt fee.

### Quick start — no technical knowledge needed

1. Open **Google Maps**, search for the shop, restaurant, hotel or other business, and open its business panel.
2. Copy the full address-bar URL, or click **Share → Copy link**.
3. Paste it into **Google Maps business links**. Remove the sample link first. You can add several businesses.
4. Set **Maximum reviews for each business**; try 20 first. Select **Newest first** for recent feedback.
5. Click **Start**. When the run finishes, open **Output → Reviews**.
6. Download CSV or Excel for a spreadsheet, or JSON for nested photos, reviewer details and guided ratings.

Supported link forms include full Google Maps business URLs containing a Place ID/data ID/CID, `maps.app.goo.gl`, `goo.gl/maps` and `g.page` links that redirect to a recognized Google Maps business URL. A generic map/search/directions URL without a business identifier is not enough. If a share link cannot be resolved, paste the full URL from the business panel or use a Place ID.

```json
{
  "placeUrls": ["https://www.google.com/maps/place/?q=place_id:ChIJFTdlBPAoTIYRoJO88NsExVc"],
  "maxReviewsPerPlace": 20,
  "sort": "newest"
}
```

### What you receive

One dataset row represents one review. Fields include `reviewId`, `rating`, original `text`, available `translatedText`, publication/edit dates, helpful votes, review/photo links, available owner replies, guided review details, place name/address/rating/review count and input provenance.

Reviewer profile details are **off by default**. Turn on **Include public reviewer profile details** if you need the available public name, profile link, Local Guide status and contribution counts. Only use collected data for lawful purposes and respect privacy, retention and deletion obligations. There are no private contact details or identity verification services here.

Missing fields remain empty; a rating-only review can legitimately have no text. Hotel results can include third-party review sources, so inspect `source` rather than assuming every record is a native Google review. Business details and topics may be unavailable when starting from a continuation page.

The **SUMMARY** output shows page/request counts, duplicates skipped, topics, per-place outcomes, limits and safe errors. It distinguishes the total business review count from the number actually collected.

### Developer inputs

Use one or combine several input lists:

| Input | Format | Notes |
| --- | --- | --- |
| `placeUrls` | Array of URL strings | Easiest option for business users |
| `placeIds` | Array of Google Place IDs | Direct lookup; clear the example URL |
| `dataIds` | Array of `0xHEX:0xHEX` strings | Direct review lookup |
| `cids` | Array of quoted numeric strings | Requires an additional business-ID lookup |
| `startUrls` | Inline `[{"url":"https://…"}]` | Alternative URL-list format; not remote list sources |

```json
{
  "placeUrls": [],
  "dataIds": ["0x864c28f004653715:0x57c504dbf0bc93a0"],
  "maxReviewsPerPlace": 40,
  "maxReviews": 40,
  "maxRequests": 3,
  "sort": "newest",
  "includeReviewerDetails": true
}
```

#### API example (Python)

Set your **Apify token** in an environment variable. Customers do not need a separate data-service key.

```python
import os
import requests

response = requests.post(
    "https://api.apify.com/v2/acts/gauravlabs~google-maps-reviews-api/runs",
    headers={"Authorization": "Bearer " + os.environ["APIFY_TOKEN"]},
    json={
        "placeUrls": [],
        "dataIds": ["0x864c28f004653715:0x57c504dbf0bc93a0"],
        "maxReviewsPerPlace": 40,
        "maxReviews": 40,
        "sort": "newest"
    },
    timeout=30,
)
response.raise_for_status()
run = response.json()["data"]
print(run["id"])  # Poll GET /v2/actor-runs/{id} until finished.
## Then read GET /v2/datasets/{defaultDatasetId}/items with authentication.
```

The start endpoint is asynchronous: it returns a run, not completed reviews. Follow the run until `SUCCEEDED`; inspect failures and `SUMMARY` before consuming the default dataset. Apify datasets support pagination when downloading large result sets.

### Filters and incremental collection

#### Get reviews for a specific date range — no page tokens needed

Paste a business link, fill **Reviews from date** and **Reviews through date**, keep **Newest first**, and click Start. The Actor follows review pages automatically and returns only reviews whose publication dates fall inside your range. You do not need to supply or manage `nextPageToken` for a normal date-range run.

For example, to request reviews published October 1–20, 2026:

```json
{
  "placeUrls": ["https://www.google.com/maps/place/?q=place_id:ChIJFTdlBPAoTIYRoJO88NsExVc"],
  "reviewsSince": "2026-10-01",
  "reviewsUntil": "2026-10-20",
  "sort": "newest",
  "maxReviewsPerPlace": 100,
  "maxFilteredScanCostUsd": 0.05
}
```

Both dates are optional. Date-only inputs include the entire UTC day; ISO timestamps must include a timezone and are inclusive. Reviews without valid publication timestamps are skipped. This filters publication dates, not owner-reply dates or last-edit dates.

**Cost and coverage:** there is no direct jump to a historical date. The Actor may need to scan newer pages first, at the existing **$0.002 per filtered API attempt**, plus delivered-review fees. With a start date and newest sorting, it processes the whole current page and stops before requesting another page once the observed date order has passed the start date. It also checks available last-edit timestamps. Missing, invalid or out-of-order dates disable this optimization for that business to avoid silently skipping possible matches. SUMMARY reports `dateBoundaryReached` or why the optimization was disabled.

Review, request, scan-spend and time limits remain in force, so a wide or old range may return partial results or no matches. End-date-only searches cannot use a start-date cutoff. Check SUMMARY for limits and `partial`; completion under observed newest-first ordering is not proof that every historical review exists in the source. Advanced continuation tokens remain optional for manually resuming a limited run, not a prerequisite for date filtering.

- Sort by **newest**, **most relevant**, **highest rating** or **lowest rating**.
- `keyword` is a case-insensitive literal substring filter on original review text, applied locally. It is not fuzzy or semantic search. `topicId` selects a returned topic from the first-page SUMMARY using the review service. These two cannot be used together.
- Minimum/maximum stars, text-only, owner-reply-only, `reviewsSince` and `reviewsUntil` filters are applied before delivery. Date filtering requires **newest** sort and skips reviews without parseable dates. Selective filters can consume many pages without yielding many matches.
- `skipReviewIds` lets a scheduled run skip IDs from a previous export. Scheduling alone does not automatically remember prior reviews.
- `nextPageToken` resumes one business with the **same identifiers, sort, language and filters**. Copy it from SUMMARY. Tokens may expire. If a page was partially delivered, resume is not offered because a cursor would skip the remaining rows; rerun with a larger limit and skip already delivered IDs instead.

### Limits, reliability and cost controls

The collector requests up to 20 reviews per page, follows only returned continuation tokens and deduplicates review IDs within a run. It stops on repeated pages/cursors, request/page/review caps, filtered-scan charges or the time budget. It does not promise every historical review, unlimited extraction or exhaustive coverage. No AI sentiment analysis or automatic email outreach is included.

Requests are sequential. Transient service/network failures can be retried once; invalid input, access and capacity errors are not repeatedly retried. Partial completed results are retained and marked in SUMMARY. A business with no reviews can finish successfully with an empty dataset; lookup failures are reported separately, not disguised as review rows.

Default and maximum memory are **256 MB**. `maxRequests` counts API requests, short-link redirect hops, CID lookups and retries. Increase Apify's run timeout together with `maxRunSecs` for larger batches. Dense filters, duplicate inputs, sparse pages and failures can increase cost per delivered review. Overall spending limits stop additional chargeable work; a filtered attempt paid before a request is still charged if that request later fails.

### Practical uses

- Track recent customer feedback for your own locations.
- Compare review themes, ratings and owner responsiveness across businesses.
- Feed structured reviews into your own sentiment-analysis or reporting workflow.
- Build local SEO reporting and reputation-monitoring integrations.

#### Example: collect recent reviews for several locations

Add each business URL to `placeUrls`, choose `sort: "newest"`, and set `maxReviewsPerPlace` to your desired sample size. Export the results and group them by `placeName` or `inputUrl`. An ordinary unfiltered export does not incur the filtered-scan surcharge. Adding `reviewsSince` or `skipReviewIds` does activate it.

#### Example: investigate one- and two-star feedback

Set `maximumRating` to `2` and `sort` to `newest`. Use `onlyWithText` if you need written comments rather than rating-only entries. Set `maxFilteredScanCostUsd` and Apify's overall run spending limit before starting: selective filters may scan many pages and still return few matching reviews.

### Frequently asked questions

#### Can I export Google Maps reviews to Excel or CSV without coding?

Yes. Paste business links, start the Actor, then download the Reviews dataset as Excel, CSV or JSON. JSON preserves nested photos and optional reviewer details more naturally than a spreadsheet.

#### Is this a Google reviews API for developers?

Yes. Start runs using the Apify REST API or SDK, poll the run status, then fetch the dataset. You can supply Place IDs, data IDs, CIDs or supported business URLs. This is an independent service, not an official Google API.

#### Can I scrape reviews for multiple businesses?

Yes. Provide several business URLs or IDs. Set both a per-business review limit and a whole-run limit. Businesses are processed sequentially; large jobs also need suitable request and time budgets.

#### Does it include owner replies, review photos and reviewer names?

Available owner-reply text and review photos are included by default. Public reviewer profile details are optional and off by default. Fields can be missing, and exact owner-reply timestamps are not guaranteed. Follow applicable privacy and data-retention requirements.

#### Is there a free trial or an extra API key to buy?

Free Apify accounts can use available platform credits at **$2 per 1,000 delivered reviews**; paid Apify accounts pay **$0.30 per 1,000**. Filtered API attempts cost an additional **$0.002 each** on either plan. There is no separate zero-charge 1,000-review trial and no additional service key required from customers.

#### Will it return every review or find businesses for me?

It follows available review pagination for the businesses you supply, subject to your limits and data availability. It does not guarantee a complete historical archive or search for businesses by city or keyword. Generic Maps search URLs without a business identifier are not review inputs.

### Help with a run or integration

Open this Actor's **Issues** tab with your run ID, a non-sensitive input example and the expected output. Do not post API tokens, credentials or private customer data. For a specific reporting or integration requirement, describe the required fields and workflow so we can assess support; unsupported features are not promised.

### Troubleshooting

| Outcome | What to do |
| --- | --- |
| `PLACE_ID_NOT_IN_URL` | Open the business panel and copy the full Maps URL, or provide a Place ID/data ID |
| `MAPS_LINK_UNAVAILABLE` | Replace the share link with its full business URL |
| `REQUEST_LIMIT` / `TIME_BUDGET` | Increase limits carefully or collect fewer reviews |
| `FILTERED_SCAN_COST_LIMIT` | The additional scan budget was reached; increase it explicitly to scan more pages |
| `REQUEST_REJECTED` | Check identifiers, topic, keyword and continuation settings |
| `SERVICE_ACCESS_UNAVAILABLE` / `SERVICE_CAPACITY_UNAVAILABLE` | Contact the developer with your run ID; no secret credentials are exposed |
| Fewer reviews than requested | Check SUMMARY, filters, available pagination and per-place limits |

This is an independent tool, not affiliated with or endorsed by Google. Availability and fields depend on the public listing and current service responses. Search-ranking placement is not guaranteed.

# Actor input Schema

## `placeUrls` (type: `array`):

Paste one or more Google Maps business URLs or Share links. Supports full links with a business ID, maps.app.goo.gl, goo.gl/maps and g.page redirects to Maps. General search/directions links without a business identifier cannot be resolved reliably. Remove this example when using only developer IDs.

## `maxReviewsPerPlace` (type: `integer`):

Try 20 for a quick preview or 100 for a useful sample. This is a cap, not a guarantee; fewer reviews may be available.

## `sort` (type: `string`):

Newest is best for monitoring recent feedback. The Actor maps these friendly options to the review service's accepted values.

## `language` (type: `string`):

Requests localized content and available translations. Original text is preserved. Guided rating keys may be localized; use en for stable English keys.

## `country` (type: `string`):

Two-letter localization code, not a geographic filter.

## `includeReviewerDetails` (type: `boolean`):

Off by default. Turn on for available public reviewer name, profile URL, Local Guide status and contribution counts. Collect and use personal data responsibly.

## `includeImages` (type: `boolean`):

Returns image URLs when present. Does not download image files.

## `placeIds` (type: `array`):

For example ChIJFTdlBPAoTIYRoJO88NsExVc. Clear the example business link to run only these IDs. Duplicate identities are skipped.

## `dataIds` (type: `array`):

For example 0x864c28f004653715:0x57c504dbf0bc93a0. Fast direct review lookup. Do not supply a numeric CID here.

## `cids` (type: `array`):

Quoted decimal strings, for example 6324466594394968992. Requires an additional place-identity lookup before reviews. Numeric JSON values are rejected to prevent precision loss.

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

Alternative to placeUrls, using inline objects such as \[{"url":"https://www.google.com/maps?cid=6324466594394968992"}]. Remote list sources are not supported.

## `keyword` (type: `string`):

Case-insensitive literal substring filter on original text, not semantic search. Enables the $0.002-per-attempt filtered-scan fee, even for no matches or failed attempts. Cannot be combined with topicId.

## `maxFilteredScanCostUsd` (type: `number`):

Additional scan budget only; excludes delivered-review charges. $0.05 permits at most 25 filtered API attempts. Applies when keyword, topic, date, rating, text/reply-only or skip-ID filters are active. Each attempt costs $0.002, including retries, empty/failed calls and CID resolution. Set 0 to prevent filtered API calls. Also set Apify's overall maximum run charge.

## `topicId` (type: `string`):

Copy a topic ID from the first-page topics in SUMMARY. Pass it unchanged. Cannot be combined with keyword.

## `minimumRating` (type: `integer`):

Applied locally before delivery. Filtering can require more pages for the same number of results.

## `maximumRating` (type: `integer`):

Set 2 to collect one- and two-star feedback.

## `onlyWithText` (type: `boolean`):

Only deliver reviews with non-empty original text.

## `onlyWithOwnerReply` (type: `boolean`):

Only deliver reviews that include an owner-response object.

## `reviewsSince` (type: `string`):

Enter YYYY-MM-DD, e.g. 2026-10-01, or an ISO timestamp with timezone. Start is inclusive; date-only uses UTC. Use Newest first. Pagination is automatic and stops after the start-date boundary when observed dates are reliably newest-first. Missing or reordered dates disable early stopping. No page token needed. Date filters add $0.002 per API attempt; limits still apply.

## `reviewsUntil` (type: `string`):

Enter YYYY-MM-DD, e.g. 2026-10-20, to include that entire UTC day, or an inclusive ISO timestamp with timezone. Combine with From date for a range. Use Newest first. Pagination is automatic; older periods may require many pages and additional scan fees. Missing publication dates are skipped.

## `skipReviewIds` (type: `array`):

Optional incremental collection: up to 10,000 IDs. These reviews are skipped before delivery. No automatic cross-run memory is implied.

## `nextPageToken` (type: `string`):

One business only. Copy nextPageToken from SUMMARY, retain the same sort, filters and language, and optionally supply skipReviewIds. Tokens may expire. Resume is unavailable if a page was only partially delivered.

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

Global delivery cap across all input businesses.

## `maxPlaces` (type: `integer`):

Process only the first N unique input tasks.

## `maxPagesPerPlace` (type: `integer`):

Prevents expensive scanning when filters discard most reviews.

## `pageSize` (type: `integer`):

Up to 20. The service can return fewer; the Actor follows only actual continuation tokens.

## `maxRequests` (type: `integer`):

Hard cap on all review calls, CID lookups, redirect hops and retries.

## `requestRetries` (type: `integer`):

Retry a temporary network/server failure at most once.

## `requestTimeoutSecs` (type: `integer`):

Timeout for one API call, clamped to the remaining time budget.

## `maxRunSecs` (type: `integer`):

Preserve completed rows near the deadline. Apify's run timeout can impose a lower limit. The tested memory allocation is capped at 256 MB.

## Actor input object example

```json
{
  "placeUrls": [
    "https://www.google.com/maps/place/?q=place_id:ChIJFTdlBPAoTIYRoJO88NsExVc"
  ],
  "maxReviewsPerPlace": 100,
  "sort": "newest",
  "language": "en",
  "country": "us",
  "includeReviewerDetails": false,
  "includeImages": true,
  "maxFilteredScanCostUsd": 0.05,
  "minimumRating": 1,
  "maximumRating": 5,
  "onlyWithText": false,
  "onlyWithOwnerReply": false,
  "maxReviews": 1000,
  "maxPlaces": 20,
  "maxPagesPerPlace": 50,
  "pageSize": 20,
  "maxRequests": 100,
  "requestRetries": 1,
  "requestTimeoutSecs": 60,
  "maxRunSecs": 240
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

## `summary` (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 = {
    "placeUrls": [
        "https://www.google.com/maps/place/?q=place_id:ChIJFTdlBPAoTIYRoJO88NsExVc"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gauravlabs/google-maps-reviews-api").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 = { "placeUrls": ["https://www.google.com/maps/place/?q=place_id:ChIJFTdlBPAoTIYRoJO88NsExVc"] }

# Run the Actor and wait for it to finish
run = client.actor("gauravlabs/google-maps-reviews-api").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 '{
  "placeUrls": [
    "https://www.google.com/maps/place/?q=place_id:ChIJFTdlBPAoTIYRoJO88NsExVc"
  ]
}' |
apify call gauravlabs/google-maps-reviews-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gauravlabs/google-maps-reviews-api"
        }
    }
}
```

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/awKqqsV2WkeYgWWZg/builds/YICRCjMUNRcqKjwlQ/openapi.json