# Free Google Maps Scraper II (`fit_melon/free-google-maps-scraper-ii`) Actor

Free Google Maps scraper — no API key. Extract businesses & places by search term and location: name, address, phone, website, rating, category, GPS coordinates. Export to CSV, Excel, JSON. Great for lead generation & local SEO.

- **URL**: https://apify.com/fit\_melon/free-google-maps-scraper-ii.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Lead generation, Business
- **Stats:** 3 total users, 1 monthly users, 92.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Free Google Maps Scraper II 🗺️

Extract **business and place data from Google Maps** — for free. Give it a search
term (e.g. `coffee shops`, `dentist`, `plumber`) and a location (e.g. `Austin, TX`,
`Paris, France`), and get back a clean, structured dataset of places: **name,
address, phone, website, category, rating, GPS coordinates, photos, attributes** —
plus optional **e-mail & social-media enrichment**. No Google API key required.

This Actor is **free**: you only pay for your own Apify platform usage (compute +
optional proxy). There is no developer markup, no per-result fee, no monthly rent.

### Features

- 🔍 **Search by keyword + location** (auto-geocoded) or by **Google Maps URL / CID**.
- 🧭 **Geographic tiling** — split an area into an N×N grid to blow past Google's
  ~120-results-per-search limit and get exhaustive coverage.
- 📇 **Contact enrichment** — optionally visit each place's website (and its
  contact / *mentions légales* pages) to pull **e-mails and social profiles**
  (Facebook, Instagram, LinkedIn, X, YouTube, TikTok). `mailto:` links are read
  first and addresses are TLD-validated to avoid garbage.
- ⚡ **Fast** — websites are enriched **in parallel** (configurable concurrency).
- 🎯 **Quality filters** — minimum rating, category words, only-with-website,
  only-with-phone.
- 🕒 **Opening hours & live status** — today's hours and the real-time "Open · Closes 6 PM"
  / "Closed" status, straight from the search response.
- ⭐ **Deep mode (optional)** — turn on `scrapeDetails` to also get the **real review
  count**, the **full 7-day opening hours**, and **individual reviews** (author,
  rating, text, date) via a headless browser. Slower, off by default.
- 🏷️ **Rich fields** — rating, category, coordinates, phone, website, domain, photo
  thumbnail, place attributes (service options, accessibility…), neighborhood, CID,
  structured address (street / city / postal code), and reservation/booking link.
- 📊 **Rank & timestamp** on every result, run statistics saved to the key-value store.
- 🛡️ **Robust** — user-agent rotation, retries with exponential backoff, proxy support,
  and global deduplication.

### Input

| Field | Type | Description |
|---|---|---|
| `searchStringsArray` | array | Search terms; each searched separately. |
| `locationQuery` | string | Location to center on (e.g. `"Austin, TX"`), geocoded automatically. |
| `maxCrawledPlacesPerSearch` | integer | Max places per term (across tiles). Default `20`. |
| `startUrls` | array | Google Maps place URLs to scrape directly. |
| `placeIds` | array | Google Maps CIDs (numeric) to resolve directly. |
| `categoryFilterWords` | array | Keep only places whose category matches one of these words. |
| `placeMinimumStars` | string | Keep only places rated ≥ this (e.g. `"4.0"`). |
| `onlyWithWebsite` / `onlyWithPhone` | boolean | Keep only places that have a website / phone. |
| `scrapeContacts` | boolean | Visit each website to extract e-mails & social profiles. |
| `scrapeDetails` | boolean | Deep mode: review count, full weekly hours, reviews (headless browser, slow). |
| `maxReviews` | integer | In deep mode, scrape up to N reviews per place. `0` = none. |
| `detailsConcurrency` | integer | Parallel browser pages in deep mode. Keep at `1` on small runs. |
| `tiles` | integer | N×N grid for exhaustive coverage. `1` = off. |
| `language` / `countryCode` | string | Google `hl` / `gl` codes. |
| `latitude` / `longitude` / `zoom` | string/int | Manual map center & zoom. |
| `maxRetries` | integer | Attempts per request (exponential backoff). Default `3`. |
| `maxConcurrency` | integer | Parallel website visits during enrichment. Default `10`. |
| `proxyConfiguration` | object | Proxy settings (Apify Proxy recommended for larger runs). |

#### Example input

```json
{
  "searchStringsArray": ["coffee shops"],
  "locationQuery": "Austin, TX",
  "maxCrawledPlacesPerSearch": 60,
  "tiles": 3,
  "placeMinimumStars": "4.3",
  "onlyWithWebsite": true,
  "scrapeContacts": true
}
````

### Output

Each place is one dataset item:

```json
{
  "searchString": "coffee shops",
  "rank": 1,
  "title": "Epoch Coffee",
  "categoryName": "Coffee shop",
  "categories": ["Coffee shop"],
  "address": "Epoch Coffee, 221 W N Loop Blvd, Austin, TX 78751",
  "street": "221 W N Loop Blvd",
  "neighborhood": "North Loop",
  "latitude": 30.3195,
  "longitude": -97.7237,
  "totalScore": 4.5,
  "openStatus": "Open 24 hours",
  "openingHoursToday": "Open 24 hours",
  "postalCode": "78751",
  "city": "Austin",
  "reservationUrl": null,
  "phone": "(512) 454-3762",
  "website": "http://www.epochcoffee.com/",
  "domain": "epochcoffee.com",
  "emails": ["hello@epochcoffee.com"],
  "socialProfiles": { "instagram": "https://www.instagram.com/epochcoffee" },
  "thumbnail": "https://lh5.googleusercontent.com/...",
  "additionalInfo": { "Service options": ["Dine-in", "Takeaway"] },
  "timezone": "America/Chicago",
  "placeId": "0x8644ca6bc309e81b:0x1f1a903bbb66839",
  "cid": "140078896924485689",
  "url": "https://maps.google.com/?cid=140078896924485689",
  "scrapedAt": "2026-07-08T18:40:00.000Z",
  "status": "found",

  "_comment": "the fields below are added only in deep mode (scrapeDetails=true)",
  "reviewsCount": 1972,
  "openingHours": [
    { "day": "Monday", "hours": "7 AM to 7 PM" },
    { "day": "Tuesday", "hours": "7 AM to 7 PM" }
  ],
  "reviews": [
    { "author": "Venus", "rating": 3, "text": "Famous for its iconic mural…", "date": "2 months ago" }
  ]
}
```

A **Leads** dataset view (name, phone, e-mails, website, socials) is included for
lead-generation exports. Export to **CSV, Excel, JSON, or via the Apify API**.

### Use cases

- **Lead generation** — targeted lists of local businesses with phone, website, e-mail and socials.
- **Local SEO & rank tracking** — the `rank` field + daily scheduling track who ranks for a query.
- **Market research** — business density, ratings and attributes by category and city.
- **Data enrichment** — resolve names / URLs / CIDs to coordinates and structured fields.

### Limitations & fair use

- The **fast default** uses the search tier (rating, today's hours, live status,
  address, contacts). **Review count, full weekly hours and review text** require
  **deep mode** (`scrapeDetails`), which drives a headless browser — much slower and,
  because Google renders some atypical places incompletely, occasionally returns a
  place without the deep fields. It works reliably for the large majority of
  established businesses.
- Google may rate-limit high-volume runs from a single IP. Enable **Apify Proxy**
  (and residential proxies for very large runs) to keep the success rate high.
- E-mail/social enrichment depends on each business publishing that info on its
  website; coverage varies.
- Use responsibly and in line with applicable laws and terms. Scrape public business
  information only.

### More actors by this developer

Browse the full collection — 30+ free data & lead-generation Actors —
on the developer profile: **https://apify.com/fit\_melon**

# Actor input Schema

## `searchStringsArray` (type: `array`):

One or more things to search for on Google Maps, e.g. "coffee shops", "dentist", "hotels". Each term is searched separately.

## `locationQuery` (type: `string`):

Free-text location to center the search on, e.g. "Austin, TX", "Paris, France". Geocoded automatically. Leave empty to rely only on the search term.

## `maxCrawledPlacesPerSearch` (type: `integer`):

Maximum number of places to return for each search term (across all tiles). Results are paginated in pages of 20.

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

Optional. A list of Google Maps place URLs (e.g. https://www.google.com/maps/place/...) to scrape directly. Great for enriching an existing list.

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

Optional. A list of Google Maps CIDs (numeric) to resolve directly.

## `categoryFilterWords` (type: `array`):

Keep only places whose category contains one of these words (case-insensitive), e.g. "restaurant", "bar". Leave empty to keep all.

## `placeMinimumStars` (type: `string`):

Keep only places with a rating >= this value (e.g. "4.0"). Leave empty for no minimum.

## `onlyWithWebsite` (type: `boolean`):

Skip places that have no website.

## `onlyWithPhone` (type: `boolean`):

Skip places that have no phone number.

## `scrapeContacts` (type: `boolean`):

For each place that has a website, visit it and extract e-mail addresses and social media profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok). Slower, but great for lead generation.

## `scrapeDetails` (type: `boolean`):

Deep mode (headless browser): fetches the real review count, the full 7-day opening hours and individual reviews. Much slower (~20-30s/place) and best run with more memory (2-4 GB). Leave off for fast runs. Note: Google renders some atypical places incompletely — a few may come back without deep fields.

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

In deep mode, also scrape up to this many individual reviews (author, rating, text, date) per place. 0 = don't scrape review text. Higher values are slower.

## `detailsConcurrency` (type: `integer`):

How many places to process in parallel in deep mode. Headless browser pages are heavy — keep at 1 on small (1-2 GB) runs; raise to 2-3 only with 4 GB+ memory.

## `tiles` (type: `integer`):

Split the area into an N×N grid of sub-searches to exceed Google's ~120-results-per-search limit and get exhaustive coverage. 1 = off (default). Try 3 for a city. Requires a location.

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

Language code (Google `hl`), e.g. "en", "fr", "es".

## `countryCode` (type: `string`):

Country bias (Google `gl`), e.g. "us", "fr", "gb".

## `latitude` (type: `string`):

Override the map center latitude. If set with longitude, location geocoding is skipped.

## `longitude` (type: `string`):

Override the map center longitude.

## `zoom` (type: `integer`):

Map zoom level. Higher = tighter area around the center. Default 12 (city level).

## `maxRetries` (type: `integer`):

Number of attempts per request before giving up (with exponential backoff).

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

How many websites to visit in parallel when 'Enrich with e-mails & social profiles' is on. Higher = faster, but heavier on proxy/compute. Default 10.

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

Proxy settings. Recommended for larger runs. You pay only for your own Apify proxy usage; residential proxies (optional) improve success rate at scale.

## Actor input object example

```json
{
  "searchStringsArray": [
    "restaurants",
    "hotels"
  ],
  "locationQuery": "Austin, TX",
  "maxCrawledPlacesPerSearch": 20,
  "onlyWithWebsite": false,
  "onlyWithPhone": false,
  "scrapeContacts": false,
  "scrapeDetails": false,
  "maxReviews": 0,
  "detailsConcurrency": 1,
  "tiles": 1,
  "language": "en",
  "countryCode": "us",
  "zoom": 12,
  "maxRetries": 3,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchStringsArray": [
        "coffee shops"
    ],
    "locationQuery": "Austin, TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/free-google-maps-scraper-ii").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 = {
    "searchStringsArray": ["coffee shops"],
    "locationQuery": "Austin, TX",
}

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/free-google-maps-scraper-ii").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 '{
  "searchStringsArray": [
    "coffee shops"
  ],
  "locationQuery": "Austin, TX"
}' |
apify call fit_melon/free-google-maps-scraper-ii --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fit_melon/free-google-maps-scraper-ii",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Free Google Maps Scraper II",
        "description": "Free Google Maps scraper — no API key. Extract businesses & places by search term and location: name, address, phone, website, rating, category, GPS coordinates. Export to CSV, Excel, JSON. Great for lead generation & local SEO.",
        "version": "0.0",
        "x-build-id": "udvctKkfKAK3W5WjN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fit_melon~free-google-maps-scraper-ii/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fit_melon-free-google-maps-scraper-ii",
                "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/fit_melon~free-google-maps-scraper-ii/runs": {
            "post": {
                "operationId": "runs-sync-fit_melon-free-google-maps-scraper-ii",
                "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/fit_melon~free-google-maps-scraper-ii/run-sync": {
            "post": {
                "operationId": "run-sync-fit_melon-free-google-maps-scraper-ii",
                "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",
                "properties": {
                    "searchStringsArray": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "One or more things to search for on Google Maps, e.g. \"coffee shops\", \"dentist\", \"hotels\". Each term is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "Location",
                        "type": "string",
                        "description": "Free-text location to center the search on, e.g. \"Austin, TX\", \"Paris, France\". Geocoded automatically. Leave empty to rely only on the search term."
                    },
                    "maxCrawledPlacesPerSearch": {
                        "title": "Max places per search term",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of places to return for each search term (across all tiles). Results are paginated in pages of 20.",
                        "default": 20
                    },
                    "startUrls": {
                        "title": "Google Maps place URLs",
                        "type": "array",
                        "description": "Optional. A list of Google Maps place URLs (e.g. https://www.google.com/maps/place/...) to scrape directly. Great for enriching an existing list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "Place CIDs",
                        "type": "array",
                        "description": "Optional. A list of Google Maps CIDs (numeric) to resolve directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryFilterWords": {
                        "title": "Category filter",
                        "type": "array",
                        "description": "Keep only places whose category contains one of these words (case-insensitive), e.g. \"restaurant\", \"bar\". Leave empty to keep all.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeMinimumStars": {
                        "title": "Minimum rating",
                        "type": "string",
                        "description": "Keep only places with a rating >= this value (e.g. \"4.0\"). Leave empty for no minimum."
                    },
                    "onlyWithWebsite": {
                        "title": "Only places with a website",
                        "type": "boolean",
                        "description": "Skip places that have no website.",
                        "default": false
                    },
                    "onlyWithPhone": {
                        "title": "Only places with a phone number",
                        "type": "boolean",
                        "description": "Skip places that have no phone number.",
                        "default": false
                    },
                    "scrapeContacts": {
                        "title": "Enrich with e-mails & social profiles",
                        "type": "boolean",
                        "description": "For each place that has a website, visit it and extract e-mail addresses and social media profiles (Facebook, Instagram, LinkedIn, X, YouTube, TikTok). Slower, but great for lead generation.",
                        "default": false
                    },
                    "scrapeDetails": {
                        "title": "Deep details (review count, full weekly hours, reviews)",
                        "type": "boolean",
                        "description": "Deep mode (headless browser): fetches the real review count, the full 7-day opening hours and individual reviews. Much slower (~20-30s/place) and best run with more memory (2-4 GB). Leave off for fast runs. Note: Google renders some atypical places incompletely — a few may come back without deep fields.",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Max reviews per place",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "In deep mode, also scrape up to this many individual reviews (author, rating, text, date) per place. 0 = don't scrape review text. Higher values are slower.",
                        "default": 0
                    },
                    "detailsConcurrency": {
                        "title": "Deep-mode concurrency (browser pages)",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "How many places to process in parallel in deep mode. Headless browser pages are heavy — keep at 1 on small (1-2 GB) runs; raise to 2-3 only with 4 GB+ memory.",
                        "default": 1
                    },
                    "tiles": {
                        "title": "Geographic grid (tiling)",
                        "minimum": 1,
                        "maximum": 7,
                        "type": "integer",
                        "description": "Split the area into an N×N grid of sub-searches to exceed Google's ~120-results-per-search limit and get exhaustive coverage. 1 = off (default). Try 3 for a city. Requires a location.",
                        "default": 1
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code (Google `hl`), e.g. \"en\", \"fr\", \"es\".",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Country bias (Google `gl`), e.g. \"us\", \"fr\", \"gb\".",
                        "default": "us"
                    },
                    "latitude": {
                        "title": "Latitude (optional)",
                        "type": "string",
                        "description": "Override the map center latitude. If set with longitude, location geocoding is skipped."
                    },
                    "longitude": {
                        "title": "Longitude (optional)",
                        "type": "string",
                        "description": "Override the map center longitude."
                    },
                    "zoom": {
                        "title": "Zoom (1-21)",
                        "minimum": 1,
                        "maximum": 21,
                        "type": "integer",
                        "description": "Map zoom level. Higher = tighter area around the center. Default 12 (city level).",
                        "default": 12
                    },
                    "maxRetries": {
                        "title": "Max retries per request",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Number of attempts per request before giving up (with exponential backoff).",
                        "default": 3
                    },
                    "maxConcurrency": {
                        "title": "Concurrency (contact enrichment)",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "How many websites to visit in parallel when 'Enrich with e-mails & social profiles' is on. Higher = faster, but heavier on proxy/compute. Default 10.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Recommended for larger runs. You pay only for your own Apify proxy usage; residential proxies (optional) improve success rate at scale.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```