# Foursquare Locations Scraper (`automation-lab/foursquare-locations-scraper`) Actor

🏪 Export public Foursquare brand locations by city with venue IDs, addresses, phones, coordinates, hours, ratings, selected tips, photos, and source links.

- **URL**: https://apify.com/automation-lab/foursquare-locations-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Foursquare Locations Scraper

Extract public Foursquare venue records from brand-and-city location pages without an account or Foursquare API key.

Turn URLs such as `https://redirect.foursquare.com/locations/starbucks/new-york-city` into clean JSON, CSV, Excel, XML, or RSS datasets containing venue names, addresses, phones, coordinates, opening hours, ratings, selected tips, photos, and source links.

Use the Actor for chain expansion analysis, local lead lists, hospitality research, recurring directory refreshes, and brand-footprint monitoring.

### What does Foursquare Locations Scraper do?

Foursquare Locations Scraper reads public Foursquare brand directory pages and saves one venue per dataset row.

It supports two equivalent input routes:

- 🏪 paste exact Foursquare `/locations/<brand>/<city>` URLs;
- 📍 provide brand and city pairs and let the Actor build safe URL slugs;
- 🎯 combine multiple cities in one run;
- 🧹 deduplicate repeated venues by their Foursquare venue ID;
- ⛔ stop at a global `maxItems` limit.

The current public page embeds up to 30 detailed venue records per supplied brand/city URL. The output also includes Foursquare's displayed total location count so you can assess the wider footprint without confusing it with the number exported by the page.

### Who is it for?

#### Retail and chain expansion teams

Compare where a brand appears across cities, inspect neighborhood coverage, and feed coordinates into market maps.

#### Lead generation teams

Build targeted venue lists with phone numbers, addresses, websites, and opening hours for compliant business outreach.

#### Hospitality and local-market analysts

Compare categories, ratings, rating-signal counts, selected tips, and hours across public venue listings.

#### Data and reputation teams

Schedule recurring exports and diff the latest Foursquare records against a warehouse snapshot.

#### Developers and AI agents

Use the Apify API or MCP to turn a brand/city request into structured place data without maintaining a parser.

### Why use this Foursquare scraper?

- ⚡ **HTTP-first:** no browser startup or paid API credentials.
- 🧭 **Source-specific:** records retain Foursquare venue IDs and canonical links.
- 📦 **Export ready:** download JSON, CSV, Excel, XML, or RSS from the dataset.
- 🔁 **Repeatable:** save the input as an Apify Task and schedule it.
- 💳 **Pay per result:** charges apply only to unique venue rows produced, plus a small run start fee.
- 🛡️ **Fail closed:** invalid hosts, malformed location paths, and empty extraction fail visibly.

### What Foursquare location data can I extract?

| Field | Description |
|---|---|
| `venueId` | Stable Foursquare venue identifier |
| `name` | Public venue name |
| `brand` | Brand slug converted to readable text |
| `queryCity` | City requested in the source URL |
| `category` | Primary Foursquare venue category |
| `neighborhood` | Neighborhood label when available |
| `address`, `crossStreet` | Street and cross-street details |
| `city`, `state`, `postalCode`, `country` | Address components |
| `latitude`, `longitude` | Venue coordinates |
| `phone`, `formattedPhone` | Contact number variants |
| `website` | Venue or brand website supplied by Foursquare |
| `rating`, `ratingSignals` | Foursquare rating and signal count |
| `verified` | Whether Foursquare marks the venue verified |
| `isOpen`, `hoursStatus` | Current opening state and status text |
| `hours`, `popularHours` | Flattened weekly schedules |
| `menuUrl` | Public menu link when present |
| `directionsUrl` | Ready-to-open coordinate directions link |
| `tipText`, `tipAuthor`, `tipUrl` | One selected public Foursquare tip |
| `imageUrls` | Up to three public venue image URLs |
| `venueUrl`, `sourceUrl` | Canonical venue and directory links |
| `sourceTotalLocations` | Total locations reported by the source page |
| `scrapedAt` | UTC extraction timestamp |

Optional fields are omitted when Foursquare does not publish them for a venue. The Actor does not invent missing contacts, ratings, or hours.

### How much does it cost to scrape Foursquare locations?

Pricing is pay per event:

- **Run start:** $0.005 per run.
- **Venue:** tiered by your Apify plan; the BRONZE price is $0.000091861 per unique saved venue.

A 10-venue starter run is about $0.00592 at the BRONZE rate. A 30-venue page is about $0.00776. Your exact price is shown in Apify Console before the run and may be lower on higher plans.

The free Apify plan includes monthly platform credits, so small tests may fit inside those credits. Keep `maxItems` low while validating a new brand/city URL.

### How to scrape Foursquare locations

1. Open the Actor input page.
2. Paste one or more public Foursquare brand/city URLs, or add brand/city objects.
3. Set `maxItems` to the most venues you want saved.
4. Click **Start**.
5. Review the **Foursquare venues** dataset view.
6. Export the data as JSON, CSV, Excel, XML, or RSS.
7. Save the run as a Task if you want recurring updates.

### Input parameters

| Parameter | Type | Required | Purpose |
|---|---|---:|---|
| `startUrls` | array | conditional | Exact `redirect.foursquare.com/locations/<brand>/<city>` URLs |
| `locations` | array | conditional | Objects with `brand` and `city` strings |
| `maxItems` | integer | no | Global unique venue limit; default 10 |

Provide at least one `startUrls` or `locations` entry. If both are present, the Actor processes both and deduplicates canonical input URLs and venue IDs.

### Input example: exact URL

```json
{
  "startUrls": [
    { "url": "https://redirect.foursquare.com/locations/starbucks/new-york-city" }
  ],
  "maxItems": 10
}
````

Only HTTPS URLs on `redirect.foursquare.com` with exactly two path slugs are accepted. A venue detail URL, arbitrary website, or another Foursquare host fails before scraping.

### Input example: brand and city

```json
{
  "locations": [
    { "brand": "Starbucks", "city": "New York City" },
    { "brand": "Starbucks", "city": "Chicago" }
  ],
  "maxItems": 40
}
```

Names are normalized to lowercase URL slugs. For unusual branding, use the exact URL copied from Foursquare to avoid ambiguity.

### Output example

```json
{
  "venueId": "51964c1a498eeaca10e9ea4c",
  "name": "Starbucks",
  "brand": "starbucks",
  "queryCity": "new york city",
  "category": "Coffee Shop",
  "neighborhood": "Upper East Side",
  "address": "822 Lexington Ave",
  "city": "New York",
  "state": "NY",
  "postalCode": "10065",
  "country": "United States",
  "latitude": 40.76462850100318,
  "longitude": -73.96668685798046,
  "formattedPhone": "(212) 572-0984",
  "rating": 6,
  "ratingSignals": 213,
  "verified": true,
  "hoursStatus": "Closed until 5:00 AM",
  "tipText": "Service is slow but they are friendly",
  "venueUrl": "https://app.foursquare.com/v/starbucks/51964c1a498eeaca10e9ea4c",
  "sourceUrl": "https://redirect.foursquare.com/locations/starbucks/new-york-city",
  "sourceTotalLocations": 317,
  "scrapedAt": "2026-07-21T00:00:00.000Z"
}
```

### Page coverage and limits

Foursquare's public brand/city page currently embeds up to 30 venue objects while separately reporting a larger total count for some chains.

This Actor exports the useful records actually embedded in every supplied URL. It does not claim that one URL exports every venue in the reported total.

To build a wider market sample, supply additional city pages. `maxItems` is a global cap across those pages, not a promise that a page contains that many records.

### Tips for reliable runs

- ✅ Copy the public brand/city URL from Foursquare when possible.
- ✅ Begin with `maxItems: 10` to inspect the result shape.
- ✅ Use separate city URLs for a multi-market comparison.
- ✅ Store `venueId` as the warehouse merge key.
- ✅ Compare `scrapedAt` and `sourceUrl` when refreshing records.
- ❌ Do not pass individual venue detail URLs.
- ❌ Do not assume every venue has a phone, rating, menu, tip, or photo.

### Scheduling a Foursquare monitor

Create an Apify Task from a tested input, then add a daily, weekly, or monthly schedule.

A practical refresh workflow is:

1. run the same brand/city list each week;
2. export rows to a named table or warehouse;
3. join on `venueId`;
4. detect newly seen and missing locations;
5. compare rating, hours, and contact changes;
6. alert only on meaningful differences.

The Actor itself does not retain previous snapshots or label a venue as opened or closed. Your destination system controls that business logic.

### Integrations

#### Google Sheets

Use the Apify Google Sheets integration to refresh a city-by-city location tracker for non-technical analysts.

#### Make

Trigger a run from a scenario, wait for completion, iterate dataset rows, and route qualified venues into a CRM.

#### Zapier

Start a saved Task on demand and send newly matched venue rows into sales or operations workflows.

#### Webhooks

Attach a run-succeeded webhook that notifies your ETL service with the dataset ID.

#### Warehouses and BI

Pull dataset JSON through the API and upsert on `venueId` into BigQuery, Snowflake, PostgreSQL, or a lakehouse.

### Use the Actor with the Apify API

The Actor ID is `automation-lab/foursquare-locations-scraper`.

Keep your Apify token in an environment variable. Never commit it to source control.

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/foursquare-locations-scraper').call({
  locations: [{ brand: 'Starbucks', city: 'New York City' }],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/foursquare-locations-scraper').call(run_input={
    'locations': [{'brand': 'Starbucks', 'city': 'New York City'}],
    'maxItems': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~foursquare-locations-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations":[{"brand":"Starbucks","city":"New York City"}],"maxItems":10}'
```

Use the returned run and dataset IDs to poll status and download results.

### Use Foursquare Locations Scraper through MCP

Apify MCP lets Claude Code, Claude Desktop, Cursor, and VS Code call the Actor as a tool.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/foursquare-locations-scraper"
```

For Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/foursquare-locations-scraper"
    }
  }
}
```

Example prompts:

- “Scrape 10 Starbucks locations from Foursquare in New York City.”
- “Compare public Foursquare ratings and hours for this brand in Chicago and Los Angeles.”
- “Return a CSV-ready list of venue IDs, phones, addresses, and coordinates.”

### Data quality

The Actor preserves source values and omits unavailable optional fields rather than filling them with guesses.

Ratings and tips are public Foursquare signals, not independent verification. Opening status can change after scraping. Phone numbers and websites may belong to a chain rather than a specific branch when that is what the source publishes.

Always review a sample before using the data for decisions or outreach.

### Error handling

The run fails with a clear error when:

- no URL or brand/city input is supplied;
- a URL uses another domain, protocol, or path shape;
- a brand/city object has an empty value;
- Foursquare returns a non-200 response;
- the public page no longer contains the expected embedded state;
- all fetched pages yield zero venue records.

One malformed request cannot silently become an empty successful dataset.

### Is it legal to scrape Foursquare locations?

This Actor accesses public web pages without bypassing a login or CAPTCHA.

You are responsible for your use case. Review Foursquare's terms, applicable database and privacy laws, and outreach rules in your jurisdiction. Do not use public contact information for spam, harassment, sensitive profiling, or unlawful discrimination.

Avoid republishing copyrighted photos or tip text beyond what your use case permits. Minimize stored personal information and honor valid deletion or correction requests.

### Limitations

- One supplied page currently exposes up to 30 detailed venue records.
- The reported total may exceed exported rows.
- Only public brand/city location pages are supported.
- Individual venue URLs and free-form category search are out of scope.
- Optional fields vary by venue.
- Foursquare can change its page markup or embedded payload.
- The Actor does not enrich emails, social profiles, or private API data.
- The Actor does not infer openings, closures, or ownership changes.

### Troubleshooting

#### Why did my URL fail validation?

Confirm it begins with `https://redirect.foursquare.com/locations/` and contains exactly a brand slug and city slug. Remove query parameters, venue detail paths, and copied tracking URLs.

#### Why did I receive fewer venues than `maxItems`?

`maxItems` is a ceiling. The public page may expose fewer records, and duplicate venue IDs across inputs are saved only once.

#### Why is a phone, rating, photo, or tip missing?

Foursquare does not publish every optional field for every venue. Missing fields are omitted rather than represented as invented values.

#### What should I do after a source-layout error?

Retry once later to rule out a transient response. If it persists, include the public source URL and run ID in an issue so the parser can be checked against the current page.

### Frequently asked questions

#### Does this Actor need a Foursquare API key?

No. It reads anonymous public brand/city pages.

#### Does it use a browser or residential proxy?

No. The current implementation uses direct HTTP and embedded structured state.

#### Can it scrape every Foursquare venue in a city?

No. It is intentionally bounded to the records exposed by supplied public brand/city pages.

#### Can I export to Excel?

Yes. Choose Excel from the dataset export menu after the run.

#### Are duplicate venues charged twice?

No. Duplicate Foursquare venue IDs are skipped before saving and charging.

#### Can I schedule it?

Yes. Save a tested input as an Apify Task and attach a schedule.

### Related scrapers

Combine this source-specific dataset with other Automation Lab tools when your workflow needs broader local-market coverage:

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — discover businesses by map query and enrich lead fields.
- [Zomato Restaurant Search Scraper](https://apify.com/automation-lab/zomato-restaurant-search-scraper) — build restaurant-specific market lists.
- [OpenStreetMap Scraper](https://apify.com/automation-lab/openstreetmap-scraper) — retrieve open map place data when Foursquare-specific signals are not required.

Use source IDs separately. Do not assume that similarly named records from different platforms are the same venue without a careful address or coordinate match.

### Support

If a valid public brand/city URL stops working, open an Actor issue and include:

- the input URL or brand/city pair;
- the Apify run ID;
- the expected result;
- the actual error or missing field;
- whether the same page opens anonymously in your browser.

That evidence makes source changes faster to reproduce and fix.

# Actor input Schema

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

Add public URLs in the exact form https://redirect.foursquare.com/locations/<brand>/<city>.

## `locations` (type: `array`):

Construct Foursquare location URLs from brand and city names or slugs.

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

Stop after saving this many unique venue rows across all inputs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://redirect.foursquare.com/locations/starbucks/new-york-city"
    }
  ],
  "locations": [],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://redirect.foursquare.com/locations/starbucks/new-york-city"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/foursquare-locations-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 = {
    "startUrls": [{ "url": "https://redirect.foursquare.com/locations/starbucks/new-york-city" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/foursquare-locations-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 '{
  "startUrls": [
    {
      "url": "https://redirect.foursquare.com/locations/starbucks/new-york-city"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/foursquare-locations-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/foursquare-locations-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Foursquare Locations Scraper",
        "description": "🏪 Export public Foursquare brand locations by city with venue IDs, addresses, phones, coordinates, hours, ratings, selected tips, photos, and source links.",
        "version": "0.1",
        "x-build-id": "oXeEG7Rq0tgKTgAdC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~foursquare-locations-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-foursquare-locations-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/automation-lab~foursquare-locations-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-foursquare-locations-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/automation-lab~foursquare-locations-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-foursquare-locations-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",
                "properties": {
                    "startUrls": {
                        "title": "🏪 Foursquare brand/city URLs",
                        "type": "array",
                        "description": "Add public URLs in the exact form https://redirect.foursquare.com/locations/<brand>/<city>.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locations": {
                        "title": "📍 Brand and city pairs",
                        "type": "array",
                        "description": "Construct Foursquare location URLs from brand and city names or slugs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "brand",
                                "city"
                            ],
                            "properties": {
                                "brand": {
                                    "title": "Brand",
                                    "type": "string",
                                    "description": "Brand name or Foursquare slug, for example Starbucks."
                                },
                                "city": {
                                    "title": "City",
                                    "type": "string",
                                    "description": "City name or Foursquare slug, for example New York City."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Maximum venues",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique venue rows across all inputs.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```