# Five Below Store Locations Scraper (`automation-lab/five-below-store-locations-scraper`) Actor

📍 Export official Five Below stores with addresses, phones, coordinates, weekly hours, canonical URLs, and source freshness for retail and POI analysis.

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

## Pricing

Pay per event

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

## Five Below Store Locations Scraper

Export the official Five Below store directory into clean JSON, CSV, Excel, XML, or Parquet records.

The Actor crawls `locations.fivebelow.com` directly and returns one row per store, including its official URL, address, phone, coordinates, weekly opening hours, and source freshness timestamp.

Use it for a complete US export or narrow the run to selected states, cities, or official Five Below URLs.

- 📍 Build a current Five Below location database.
- 🕒 Monitor openings, closures, and weekly hours changes.
- 🗺️ Map store coverage with source-provided coordinates.
- 🔄 Schedule recurring refreshes without maintaining crawler infrastructure.

### What does Five Below Store Locations Scraper do?

Five Below Store Locations Scraper traverses the retailer's official country, state, city, and store directory pages.

It reads semantic structured data published by Five Below's location platform rather than substituting third-party POI data.

Each unique canonical store URL becomes one dataset item.

The Actor supports:

- the complete official US directory;
- one or more two-letter state codes;
- one or more official state/city paths;
- official country, state, city, or store start URLs;
- a maximum-store limit for samples and bounded workflows.

### Who is this Five Below location data for?

#### Retail analysts

Measure geographic coverage, compare store density, and keep a reproducible location snapshot.

#### Commercial real-estate and site-selection teams

Combine addresses and coordinates with demographics, footfall, or competitor locations.

#### Suppliers and distributors

Plan territories, delivery coverage, and account lists around active Five Below stores.

#### POI and geospatial data teams

Refresh a source-attributed brand layer with canonical store identities and coordinates.

#### Market researchers

Schedule exports and compare snapshots to detect additions, removals, and hours changes.

### Why use this Actor?

- ✅ **Official source:** records come from `locations.fivebelow.com`.
- ✅ **Structured output:** no manual spreadsheet cleanup is required.
- ✅ **Flexible scope:** run nationwide, by state, by city, or by URL.
- ✅ **Stable identity:** canonical URLs support deduplication and snapshot comparison.
- ✅ **Freshness context:** `sourceAsOf` records the source's published timestamp when available.
- ✅ **Automation-ready:** connect schedules, webhooks, APIs, Make, Zapier, or MCP.
- ✅ **Pay per event:** pay for the run start and store records produced, not crawler engineering time.

### What Five Below store data can I extract?

| Field | Description |
|---|---|
| `storeId` | Stable slug derived from the canonical store URL |
| `name` | Store name published by Five Below |
| `url` | Canonical official store page |
| `streetAddress` | Street address |
| `city` | City or locality |
| `state` | Two-letter state code |
| `postalCode` | ZIP code |
| `country` | Country code |
| `phone` | Public store phone number when available |
| `latitude` | Source-provided latitude |
| `longitude` | Source-provided longitude |
| `mondayHours`–`sundayHours` | Opening and closing time for each day |
| `sourceAsOf` | Freshness timestamp published by the location source |
| `scrapedAt` | UTC timestamp when this Actor extracted the record |

### How to scrape Five Below store locations

1. Open Five Below Store Locations Scraper in Apify Console.
2. Keep the prefilled Alameda city URL for a quick first run, or choose another scope.
3. Optionally enter state codes such as `CA` and `TX`.
4. Optionally enter city paths such as `ca/alameda`.
5. Set **Maximum stores** to the number of records you need.
6. Click **Start** and wait for the dataset to appear.
7. Export the dataset or connect it to your downstream workflow.

Leave all location scope fields empty to traverse the complete official US directory.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | Alameda city URL in prefill | Official Five Below directory or store URLs |
| `stateCodes` | string array | empty | Two-letter state codes, for example `CA` |
| `cityPaths` | string array | empty | Official paths, for example `tx/austin` |
| `maxItems` | integer | 2,000 | Maximum unique stores to save |
| `maxConcurrency` | integer | 10 | Official pages fetched in parallel |

Scope fields are combined. Duplicate stores are still emitted only once.

Only URLs on `https://locations.fivebelow.com` are accepted.

### Input examples

#### One city

```json
{
  "cityPaths": ["ca/alameda"],
  "maxItems": 25,
  "maxConcurrency": 5
}
````

#### Two states

```json
{
  "stateCodes": ["CA", "TX"],
  "maxItems": 1000,
  "maxConcurrency": 10
}
```

#### One official store URL

```json
{
  "startUrls": [
    { "url": "https://locations.fivebelow.com/ca/alameda/2251-s-shore-center" }
  ],
  "maxItems": 1
}
```

### Output example

```json
{
  "storeId": "2251-s-shore-center",
  "name": "Five Below",
  "url": "https://locations.fivebelow.com/ca/alameda/2251-s-shore-center",
  "streetAddress": "2251 S Shore Center",
  "city": "Alameda",
  "state": "CA",
  "postalCode": "94501",
  "country": "US",
  "phone": "+15109372270",
  "latitude": 37.75685830777547,
  "longitude": -122.25036110077838,
  "mondayHours": "09:30-21:30",
  "sundayHours": "10:00-20:00",
  "sourceAsOf": "2026-07-16T15:44:20Z",
  "scrapedAt": "2026-07-22T03:00:00.000Z"
}
```

Optional fields are omitted when the official page does not publish them.

### How much does it cost to scrape Five Below store locations?

This Actor uses pay-per-event pricing:

- a small one-time **Start** fee covers run setup;
- an **Item** fee is charged for each unique store saved;
- subscription tiers receive automatic per-store discounts.

The exact live prices are displayed in Apify Console before you start a run.

A city sample is inexpensive, while a full national export scales with the number of stores returned.

You can use the Apify free plan credits for a small trial when your account and current pricing allow it.

### Tips for reliable location exports

- 🎯 Start with one city to inspect the output fields.
- 🏷️ Use state codes for regional exports instead of manually collecting city URLs.
- 🔗 Save canonical `url` as the durable identity for snapshot comparisons.
- 🕒 Compare `sourceAsOf` and `scrapedAt` separately: one belongs to the source, the other to your run.
- 📊 Export JSON for pipelines and CSV or Excel for analyst review.
- 🔄 Schedule nationwide refreshes at a cadence that matches your business need.
- 🧮 Use `maxItems` to keep development and proof-of-concept runs bounded.

### Scheduling and change monitoring

Apify schedules can run the Actor daily, weekly, or monthly.

For a location-monitor workflow:

1. Run the same scope on a schedule.
2. Save or export each dataset snapshot.
3. Join records by canonical `url`.
4. Flag new URLs as potential openings.
5. Flag missing URLs as potential closures for review.
6. Compare daily-hours fields to detect schedule changes.

A missing record should be verified before making operational decisions because source pages can change temporarily.

### Integrations

#### Google Sheets and Excel reporting

Send each scheduled dataset to a spreadsheet for territory planning and analyst review.

#### Webhooks and data warehouses

Trigger a webhook after successful runs, then load canonical store rows into BigQuery, Snowflake, or Postgres.

#### Make and Zapier

Use new dataset items to update a CRM, notify a site-selection channel, or refresh a location inventory.

#### Geospatial analysis

Load latitude and longitude into GIS software to calculate coverage, proximity, and market gaps.

#### Snapshot diff pipelines

Compare canonical URLs and hours fields between runs to detect potential location changes.

### Use Five Below Store Locations Scraper with the API

Replace `YOUR_APIFY_TOKEN` with a token from Apify Console.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/five-below-store-locations-scraper').call({
  stateCodes: ['CA'],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/five-below-store-locations-scraper').call(run_input={
    'cityPaths': ['ca/alameda'],
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~five-below-store-locations-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"stateCodes":["TX"],"maxItems":100}'
```

### Use the Actor through MCP

Connect the Actor to Claude Code with the Apify MCP server:

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

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server configuration:

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

Example prompts:

- “Export Five Below stores in California and group them by city.”
- “Get Five Below stores in Alameda with coordinates and weekly hours.”
- “Run the Five Below location scraper for Texas and summarize coverage by ZIP code.”

### Data quality and source behavior

The Actor requires store identity and core address fields before saving a record.

Phone, coordinates, hours, and source freshness are included when published by the official page.

Directory and store pages are parsed from semantic JSON-LD, with certified location facts preferred when available.

Canonical official URLs are normalized and deduplicated within each run.

If no store can be extracted from the supplied scope, the run fails instead of silently returning a misleading empty success.

### Is it legal to scrape Five Below locations?

The Actor accesses publicly available business-location information from Five Below's official directory without logging in.

Business addresses, public store phones, coordinates, and opening hours are commonly used for market research and location services.

You are responsible for your use of the data, contractual obligations, and compliance with applicable laws and source terms.

Do not use the output for harassment, deception, or unlawful targeting.

When in doubt, consult qualified legal counsel.

### Troubleshooting

#### Why did my run reject a URL?

The Actor fails closed on non-official domains and unsupported paths. Use an HTTPS URL beginning with `https://locations.fivebelow.com/`.

#### Why did my run return fewer stores than `maxItems`?

`maxItems` is a ceiling, not a promised count. A city or state scope may naturally contain fewer stores.

#### Why is an optional field missing?

The official store page may not currently publish that value. Required identity and address fields are always present in saved rows.

#### Why did a run fail with no stores extracted?

Check the state code, city slug, or official URL. Total extraction failure is intentionally reported as an error rather than an empty successful dataset.

### Frequently asked questions

#### Can I scrape all Five Below stores in the USA?

Yes. Leave all scope fields empty or supply the official directory root, and set `maxItems` high enough for the directory.

#### Can I target multiple states?

Yes. Add multiple two-letter values to `stateCodes`.

#### Can I target one store?

Yes. Supply its official Five Below location URL and set `maxItems` to `1`.

#### Does the Actor use Google Maps data?

No. It uses Five Below's official location directory and source-published coordinates.

#### Can I schedule recurring exports?

Yes. Use Apify schedules and integrations to refresh the same input automatically.

#### What export formats are available?

Apify datasets support JSON, CSV, Excel, XML, RSS, and Parquet downloads.

### Related scrapers

Combine this official brand directory with other Automation Lab tools when your workflow needs broader enrichment:

- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) for cross-source local business discovery.
- [Website Contact Scraper](https://apify.com/automation-lab/website-contact-scraper) for public website contact enrichment.
- [URL Status Checker](https://apify.com/automation-lab/url-status-checker) for monitoring saved canonical location URLs.

Use only the tools relevant to your lawful workflow and verify source differences before merging datasets.

### Support

If the official Five Below directory changes or a valid scope fails, open an issue from the Actor's Apify page.

Include:

- the exact input;
- the run URL;
- the expected state, city, or store;
- a short description of the missing or incorrect result.

That evidence makes source changes faster to diagnose and fix.

# Actor input Schema

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

Optional Five Below country, state, city, or store URLs. Leave all scope fields empty to crawl the full US directory.

## `stateCodes` (type: `array`):

Optional two-letter US state codes, such as CA or TX.

## `cityPaths` (type: `array`):

Optional official state/city slugs, such as ca/alameda or tx/austin.

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

Stop after this many unique store records.

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

Number of official directory pages fetched in parallel.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://locations.fivebelow.com/ca/alameda"
    }
  ],
  "stateCodes": [],
  "cityPaths": [],
  "maxItems": 10,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Open the default dataset table containing one item per unique official Five Below store.

# 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://locations.fivebelow.com/ca/alameda"
        }
    ],
    "stateCodes": [],
    "cityPaths": [],
    "maxItems": 10,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/five-below-store-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://locations.fivebelow.com/ca/alameda" }],
    "stateCodes": [],
    "cityPaths": [],
    "maxItems": 10,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/five-below-store-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://locations.fivebelow.com/ca/alameda"
    }
  ],
  "stateCodes": [],
  "cityPaths": [],
  "maxItems": 10,
  "maxConcurrency": 5
}' |
apify call automation-lab/five-below-store-locations-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Five Below Store Locations Scraper",
        "description": "📍 Export official Five Below stores with addresses, phones, coordinates, weekly hours, canonical URLs, and source freshness for retail and POI analysis.",
        "version": "0.1",
        "x-build-id": "8w7eSw7sRRghSAWbS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~five-below-store-locations-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-five-below-store-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~five-below-store-locations-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-five-below-store-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~five-below-store-locations-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-five-below-store-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": "🔗 Official start URLs",
                        "type": "array",
                        "description": "Optional Five Below country, state, city, or store URLs. Leave all scope fields empty to crawl the full US directory.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "stateCodes": {
                        "title": "🏷️ State codes",
                        "type": "array",
                        "description": "Optional two-letter US state codes, such as CA or TX.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "cityPaths": {
                        "title": "🏙️ City paths",
                        "type": "array",
                        "description": "Optional official state/city slugs, such as ca/alameda or tx/austin.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum stores",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many unique store records.",
                        "default": 2000
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of official directory pages fetched in parallel.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```