# Raising Cane's Store Details & Hours Scraper (`datacach/raising-canes-store-details-scraper`) Actor

Scrape Raising Cane's store details from location page URLs: address, phone, ZIP, GPS coordinates, and opening hours. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/datacach/raising-canes-store-details-scraper.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 stores

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Raising Cane's Store Details & Hours Scraper

Extract full **store details and opening hours for every Raising Cane's location** — address, phone, GPS coordinates, amenities, and ordering links — and export them to JSON, CSV, or Excel.

### What is the Raising Cane's Store Details & Hours Scraper?

This Actor **scrapes complete restaurant details for Raising Cane's locations** from the public location pages at [locations.raisingcanes.com](https://locations.raisingcanes.com/). For each location page URL you supply, it extracts the **store ID, name, full street address, phone number, latitude and longitude, opening hours, amenities, pickup and delivery options, opening date, Google Place ID, and per-store ordering links** — and returns them as one clean, structured record.

It is the **detail half of a two-Actor pair**. Its input is a list of Raising Cane's location page URLs, which is exactly what the companion **[Raising Cane's Store Locator Link Scraper](https://apify.com/datacach/raising-canes-store-locator-scraper)** produces. Run the link scraper first, pipe its output into this Actor, and you get a complete, up-to-date Raising Cane's store directory with **30 data fields per restaurant**.

Because it runs on the Apify platform, you get **scheduling, run monitoring, a full REST API, proxy rotation, and integrations** with Zapier, Make, Google Sheets, Slack, and webhooks out of the box.

### What can the Raising Cane's scraper do?

- 📍 **Extract 30 fields per store** — identifiers, address, geolocation, contact, hours, amenities, and links.
- 🕒 **Capture four separate hours objects** — general, dine-in, walk-up window, and temporary hours (see [A note on hours](#a-note-on-hours)).
- 🗺️ **Return Google Place IDs and third-party listings** so you can join Raising Cane's data to Google Maps, Yelp, Facebook, Apple Maps, and Bing.
- 🔗 **Accept bulk URL lists** — paste hundreds of location URLs; duplicates are removed automatically.
- ⚡ **Tune scraping speed** with an adjustable concurrency setting (1–20 parallel requests).
- 🛡️ **Survive bad links** — blocked or failing URLs are logged and skipped; the run only fails if nothing succeeds.
- 📤 **Export to JSON, CSV, Excel, HTML, or XML**, or pull results straight from the Apify API.
- 🔄 **Schedule recurring runs** to keep a store database fresh as Raising Cane's opens new restaurants.

### Free vs Premium: how many Raising Cane's locations can I scrape?

The Actor behaves identically on every plan except for **one limit: how many location URLs a single run will process.**

| | **Free Apify plan** | **Paid Apify plan** |
|---|---|---|
| **Location URLs processed per run** | First **5** URLs only | **Unlimited** — every URL you submit |
| Data fields returned | All 30 | All 30 |
| Scraping speed / concurrency | Same (1–20) | Same (1–20) |
| Output formats | All | All |
| API, scheduling, integrations | Yes | Yes |

**How the cap works.** On a free plan the Actor first **deduplicates** your input list, then processes only the **first 5 location URLs** and writes a warning to the run log:

````

Free plan detected — limiting to the first 5 links (restaurants).
Upgrade your plan to remove these limits.

````

On a paid plan no cap is applied and **all submitted URLs are scraped**.

Your plan is detected automatically from the Apify run environment. If that detection fails for any reason, the Actor **conservatively assumes the free plan** and applies the 5-URL cap, so a run can never silently exceed what your plan allows. Apart from this URL cap, there are **no other differences** between free and paid — no reduced speed, no withheld fields, no tiered support.

### What data does the Raising Cane's scraper extract?

Every dataset item contains the following 30 fields.

| Field | Description |
|---|---|
| `url` | The location page the record was extracted from |
| `store_id` | Store code (e.g. `PRG2`, `C888`) — stable across runs, use it to join or dedupe |
| `store_uid` | Numeric Yext entity ID for the store |
| `google_place_id` | Google Places ID — joins this record to Google Maps data |
| `slug` | Location path, e.g. `ak/anchorage/1172-north-muldoon-road` |
| `name` | Restaurant brand name |
| `site_name` | Shopping centre / site the store sits in, when published |
| `street`, `street2` | Street address, including suite or unit when present |
| `city`, `state`, `state_name`, `zipcode`, `country_code` | Rest of the address |
| `phone` | Restaurant phone number |
| `latitude`, `longitude` | Geolocation |
| `amenities` | Store features, e.g. `DRIVE_THRU`, `WALK_UP_WINDOW`, `LATE_NIGHT`, `FLAGSHIP` |
| `pickup_delivery_services` | Fulfilment options, e.g. `IN_STORE_PICKUP`, `CURBSIDE_PICKUP`, `DELIVERY_NOT_OFFERED` |
| `open_date` | Date the store opened (`YYYY-MM-DD`) |
| `description` | Store description text |
| `order_url` | Per-store online ordering link |
| `menu_url` | Menu link |
| `listings` | Third-party profile URLs — Google, Yelp, Facebook, Apple Maps, Bing |
| `hours_raw` | Opening hours as rendered on the location page |
| `dine_in_hours` | Dine-in hours, which can close earlier than `hours_raw` |
| `walk_up_window_hours` | Walk-up window hours, at stores that have one |
| `temporary_hours` | Temporary-hours field from the page data — see the note below |
| `extraction_datetime` | UTC timestamp when the item was extracted (ISO 8601), e.g. `2026-07-21T14:30:00.123456+00:00` |
| `extraction_date` | Extraction date in `mm-dd-yyyy` format, e.g. `07-21-2026` |

#### A note on hours

The location pages carry up to four separate hours objects and they do not always agree. `hours_raw` is the one the page actually renders, so treat it as authoritative. `dine_in_hours` is genuinely different at some stores (the Broadway store in New York closes its dining room an hour before the drive-thru). `temporary_hours` is published in the page data but is **not** what the site displays, and can be stale — use it only as a cross-check. Fields a store does not publish come back as `{}`.

### How do I scrape Raising Cane's store details and hours?

1. **Get your location page URLs.** The easiest way is to run the companion **[Raising Cane's Store Locator Link Scraper](https://apify.com/datacach/raising-canes-store-locator-scraper)**, which crawls the store locator and outputs every location page URL. You can also copy URLs by hand from [locations.raisingcanes.com](https://locations.raisingcanes.com/).
2. **Open this Actor** on Apify and go to the **Input** tab.
3. **Paste your URLs** into the **Location page URLs** field, one per line. Duplicates are fine — they are removed automatically. On a free plan, remember only the first 5 are processed.
4. **Optionally adjust Maximum concurrency** (default `5`). Lower it to `1` if you see blocked requests in the log.
5. **Click Start** and watch the log. Each successful store is pushed to the dataset as it completes.
6. **Download your data** from the **Output** tab in JSON, CSV, Excel, HTML, or XML — or fetch it via the Apify API.

<!-- TODO: add a screenshot of the Actor input form here, alt text: "Raising Cane's Store Details & Hours Scraper input form on Apify" -->
<!-- TODO: embed a demo video URL on its own line here so Apify Console auto-renders it -->

### Input

The Actor takes two inputs:

- **Location page URLs** (`links`, **required**) — a list of Raising Cane's location page URLs, one per line, in the form `https://locations.raisingcanes.com/<state>/<city>/<store-slug>`. Each URL produces exactly one output record. Duplicates are removed automatically.
- **Maximum concurrency** (`maxConcurrency`, optional) — how many location pages are fetched at the same time. Accepts **1 to 20**, defaults to **5**. Higher is faster but more likely to be rate-limited; set it to `1` if requests are being blocked.

Example input JSON:

```json
{
    "links": [
        "https://locations.raisingcanes.com/ak/anchorage/1172-north-muldoon-road",
        "https://locations.raisingcanes.com/al/birmingham/5301-hwy-280"
    ],
    "maxConcurrency": 5
}
````

### Output example

One dataset item per Raising Cane's restaurant. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "url": "https://locations.raisingcanes.com/ak/anchorage/1172-north-muldoon-road",
    "store_id": "PRG2",
    "store_uid": 1026188007,
    "google_place_id": "ChIJzxketmeVyFYRCyABUMBoi08",
    "slug": "ak/anchorage/1172-north-muldoon-road",
    "name": "Raising Cane's Chicken Fingers",
    "site_name": "Tikahtnu Commons",
    "street": "1172 North Muldoon Road",
    "street2": "Suite J",
    "city": "Anchorage",
    "state": "AK",
    "state_name": "Alaska",
    "zipcode": "99504",
    "country_code": "US",
    "phone": "(907) 885-3722",
    "latitude": 61.22994334371515,
    "longitude": -149.741054560268,
    "amenities": ["DRIVE_THRU"],
    "pickup_delivery_services": ["IN_STORE_PICKUP", "DELIVERY_NOT_OFFERED"],
    "open_date": "2019-03-19",
    "description": "Located in Anchorage, we serve only the highest quality chicken finger meals...",
    "order_url": "https://order.raisingcanes.com/location/north-muldoon-road-glenn-hwy-tikahtnu-commons/menu",
    "menu_url": "https://www.raisingcanes.com/menu",
    "listings": [
        { "publisher": "GOOGLEMYBUSINESS", "url": "https://maps.google.com/maps?cid=5731790125944348683" },
        { "publisher": "YELPKNOWLEDGE", "url": "http://www.yelp.com/biz/_KIScMWneTdhCTO-Fv3Uvg" }
    ],
    "hours_raw": { "monday": { "openIntervals": [{ "start": "10:00", "end": "01:00" }] } },
    "dine_in_hours": { "monday": { "openIntervals": [{ "start": "10:00", "end": "01:00" }] } },
    "walk_up_window_hours": {},
    "temporary_hours": { "monday": { "openIntervals": [{ "start": "10:00", "end": "00:00" }] } },
    "extraction_datetime": "2026-07-21T14:30:00.123456+00:00",
    "extraction_date": "07-21-2026"
}
```

### Use cases

- 🏪 **Build a Raising Cane's store directory** with full addresses, phone numbers, and hours for every US location.
- 📊 **Competitive location analysis** — map Raising Cane's footprint against your own or a rival chain's, using latitude and longitude.
- 🚚 **Delivery and logistics planning** — filter stores by `pickup_delivery_services` and `amenities` such as `DRIVE_THRU` or `CURBSIDE_PICKUP`.
- 🕒 **Opening-hours monitoring** — schedule recurring runs and diff `hours_raw` to catch schedule changes across the chain.
- 📈 **New-store tracking** — use `open_date` and scheduled runs to detect newly opened Raising Cane's restaurants.
- 🔗 **Data enrichment** — join to Google Maps, Yelp, or Facebook records via `google_place_id` and `listings`.
- 🍗 **Food-delivery and aggregator platforms** that need accurate store, hours, and ordering-link data.
- 🎓 **Market research and real-estate analysis** on quick-service restaurant expansion patterns.

### Raising Cane's–related Actors

| Actor | What it does |
|---|---|
| **[Raising Cane's Store Locator Link Scraper](https://apify.com/datacach/raising-canes-store-locator-scraper)** | Crawls the Raising Cane's store locator and outputs every location page URL. **Run this first** — its output is the ideal input for this Actor. |

### FAQ

#### Is it legal to scrape Raising Cane's location data?

This Actor collects only **publicly available data** from the same public location pages that the Raising Cane's website serves to any visitor. No personal data, logins, or private information are involved. Scraping publicly accessible information is generally legal, but you are responsible for how you use the data — review the target site's Terms of Service and consult a lawyer if your use case is commercial or sensitive. Apify also publishes a helpful guide on the [legality and ethics of web scraping](https://blog.apify.com/is-web-scraping-legal/).

#### How do I get the Raising Cane's location page URLs to feed into this Actor?

Run the **[Raising Cane's Store Locator Link Scraper](https://apify.com/datacach/raising-canes-store-locator-scraper)**, which crawls [locations.raisingcanes.com](https://locations.raisingcanes.com/) and returns every location page URL. Paste that output into the **Location page URLs** field here. You can also chain the two Actors together with an Apify integration or webhook.

#### Why did my run only return 5 Raising Cane's stores?

You are on a **free Apify plan**, which caps each run at the **first 5 location URLs** after deduplication. The run log will contain a warning saying so. Upgrade to a paid plan to process unlimited URLs. See [Free vs Premium](#free-vs-premium-how-many-raising-canes-locations-can-i-scrape) above.

#### Which hours field should I use?

Use `hours_raw` — it is what the location page actually renders and should be treated as authoritative. `dine_in_hours` genuinely differs at some stores. `temporary_hours` is present in the page data but is **not** displayed on the site and can be stale, so treat it only as a cross-check.

#### Can I run the Raising Cane's scraper via API?

Yes. Every Apify Actor is callable through the **Apify REST API** and the official [JavaScript](https://docs.apify.com/sdk/js/) and [Python](https://docs.apify.com/sdk/python/) clients. You can start runs, pass input, and fetch dataset items programmatically, or connect the Actor to Zapier, Make, Google Sheets, Slack, or a webhook.

#### Can I schedule the scraper to keep my Raising Cane's data fresh?

Yes. Use Apify **Schedules** to run the Actor daily, weekly, or on any cron expression, and enable **monitoring** to be alerted if a run fails or returns fewer results than expected.

#### What happens if some location URLs fail or are blocked?

Failing or anti-bot-blocked URLs are **logged and skipped**, and the run continues with the rest of the list. The run is only marked as failed if **no** URL succeeded. If you see many blocked requests, lower **Maximum concurrency** toward `1`.

#### Does the scraper cover Raising Cane's locations outside the US?

The Actor extracts whatever the location page publishes, including a `country_code` field. Coverage therefore matches whatever is listed on the public Raising Cane's store locator you feed it.

### Support

Found a bug, hit an edge case, or need a field the Actor does not yet extract? Open a ticket on the Actor's **Issues** tab on Apify — issues are monitored and responded to. If you need a **custom scraper** or a modified version of this Actor for a different restaurant chain or data shape, get in touch through the same channel and we can discuss a tailored solution.

# Actor input Schema

## `links` (type: `array`):

One Raising Cane's location page URL per line, in the form <code>https://locations.raisingcanes.com/\<state>/\<city>/\<store-slug></code> — for example <code>https://locations.raisingcanes.com/al/birmingham/5301-hwy-280</code>. Each URL produces exactly one output record. Duplicate URLs are removed automatically, so pasting a raw list is safe. Typically you paste the output of the <b>Raising Cane's Store Locator Link Scraper</b> Actor here. On the free plan only the first 5 URLs are scraped; paid plans have no limit.

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

How many location pages are fetched at the same time. Higher values finish large lists faster but increase the chance of being rate-limited or blocked by anti-bot protection; lower values are slower but gentler and more reliable. Accepts 1 to 20 — the default of 5 is a good balance for most runs. Set it to 1 if you are seeing blocked requests in the log.

## Actor input object example

```json
{
  "links": [
    "https://locations.raisingcanes.com/ak/anchorage/1172-north-muldoon-road",
    "https://locations.raisingcanes.com/al/birmingham/5301-hwy-280"
  ],
  "maxConcurrency": 5
}
```

# Actor output Schema

## `stores` (type: `string`):

All scraped Raising Cane's stores, one item per location page URL. Downloadable as JSON, CSV, or Excel.

## `storesCsv` (type: `string`):

The same store records exported as a CSV file.

## `runInConsole` (type: `string`):

Open this run in the Apify Console to inspect the log and the Output tab.

# 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 = {
    "links": [
        "https://locations.raisingcanes.com/ak/anchorage/1172-north-muldoon-road",
        "https://locations.raisingcanes.com/al/birmingham/5301-hwy-280"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacach/raising-canes-store-details-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 = { "links": [
        "https://locations.raisingcanes.com/ak/anchorage/1172-north-muldoon-road",
        "https://locations.raisingcanes.com/al/birmingham/5301-hwy-280",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datacach/raising-canes-store-details-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "links": [
    "https://locations.raisingcanes.com/ak/anchorage/1172-north-muldoon-road",
    "https://locations.raisingcanes.com/al/birmingham/5301-hwy-280"
  ]
}' |
apify call datacach/raising-canes-store-details-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datacach/raising-canes-store-details-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Raising Cane's Store Details & Hours Scraper",
        "description": "Scrape Raising Cane's store details from location page URLs: address, phone, ZIP, GPS coordinates, and opening hours. Export to JSON, CSV, or Excel.",
        "version": "0.0",
        "x-build-id": "2a4aWPmbQYMhCTqEW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datacach~raising-canes-store-details-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datacach-raising-canes-store-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datacach~raising-canes-store-details-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datacach-raising-canes-store-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datacach~raising-canes-store-details-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datacach-raising-canes-store-details-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "links"
                ],
                "properties": {
                    "links": {
                        "title": "Location page URLs",
                        "type": "array",
                        "description": "One Raising Cane's location page URL per line, in the form <code>https://locations.raisingcanes.com/&lt;state&gt;/&lt;city&gt;/&lt;store-slug&gt;</code> — for example <code>https://locations.raisingcanes.com/al/birmingham/5301-hwy-280</code>. Each URL produces exactly one output record. Duplicate URLs are removed automatically, so pasting a raw list is safe. Typically you paste the output of the <b>Raising Cane's Store Locator Link Scraper</b> Actor here. On the free plan only the first 5 URLs are scraped; paid plans have no limit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many location pages are fetched at the same time. Higher values finish large lists faster but increase the chance of being rate-limited or blocked by anti-bot protection; lower values are slower but gentler and more reliable. Accepts 1 to 20 — the default of 5 is a good balance for most runs. Set it to 1 if you are seeing blocked requests in the log.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
