# facebook-posts-search (`outspoken_strategy/facebook-post-search-scraper`) Actor

Search Facebook posts by keyword with recent-posts, location and date-range filters. Drop-in replacement for powerai/facebook-post-search-scraper (identical input and output schema).

- **URL**: https://apify.com/outspoken\_strategy/facebook-post-search-scraper.md
- **Developed by:** [code craker](https://apify.com/outspoken_strategy) (community)
- **Categories:** Social media, E-commerce
- **Stats:** 4 total users, 3 monthly users, 33.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Facebook Posts Search Scraper

Search Facebook posts by keyword and export them as clean, structured data — no code required.

Give it one or more keywords and the scraper returns matching public posts with their text, author, reaction breakdown, comment and share counts, media, links, timestamps and more. Filter by recent posts, location or a date range, and pull up to 5,000 results per keyword with automatic pagination.

### Features

- 🔎 **Keyword search** — find posts by any word or phrase; wrap a phrase in quotes for an exact match.
- 🧵 **Multiple keywords per run** — pass a whole list; results are combined and de-duplicated automatically.
- 🕒 **Recent-posts filter** — restrict to the freshest posts only.
- 📍 **Location filter** — narrow results to a specific location.
- 📅 **Date range** — limit posts to a start/end date.
- 📄 **Auto-pagination** — keeps loading until it reaches your result target or the feed runs out.
- 📦 **Structured output** — every post is a tidy JSON record, ready for Excel, Google Sheets, a database or your own code.

### Input

| Field                | Type    | Required | Description                                                                                     |
| -------------------- | ------- | -------- | ----------------------------------------------------------------------------------------------- |
| `query`              | string  | Yes\*    | A single keyword or phrase. Wrap in `"double quotes"` for an exact-phrase match. You can also paste several keywords, one per line. |
| `queries`            | array   | Yes\*    | A list of keywords/phrases. Each is searched separately and the results are merged and de-duplicated. `maxResults` applies **per keyword**. |
| `recent_posts`       | boolean | No       | Only return recent posts.                                                                        |
| `location_uid`       | string  | No       | Location identifier to filter posts by.                                                          |
| `start_date`         | string  | No       | Earliest post date to include (`YYYY-MM-DD`).                                                    |
| `end_date`           | string  | No       | Latest post date to include (`YYYY-MM-DD`).                                                      |
| `maxResults`         | integer | No       | Number of posts to fetch per keyword (default `10`, max `5000`).                                 |
| `cookies`            | array   | No       | Facebook session cookies (JSON). See **Authentication** below.                                   |
| `fbEmail`            | string  | No       | Facebook account email/phone for automated login. See **Authentication**.                        |
| `fbPassword`         | string  | No       | Password for that account (stored encrypted).                                                    |
| `proxyConfiguration` | object  | No       | Proxy settings. **Residential proxies are strongly recommended** (default: Apify Proxy).         |

\* Provide **either** `query` or `queries` (or both — they're merged). At least one keyword is required.

#### Example — single keyword

```json
{
    "query": "\"climate change\"",
    "maxResults": 100,
    "recent_posts": true
}
````

#### Example — multiple keywords

```json
{
    "queries": ["climate change", "renewable energy", "\"solar power\""],
    "maxResults": 50,
    "recent_posts": true
}
```

### Output

Each result is one post, saved to the dataset:

```json
{
    "post_id": "971562908763987",
    "type": "post",
    "url": "https://www.facebook.com/businessinsiderssa/posts/pfbid02cuDx...",
    "message": "Full post text...",
    "message_rich": "Full post text...",
    "timestamp": 1775211321,
    "comments_count": 152,
    "reactions_count": 1564,
    "reshare_count": 69,
    "reactions": { "like": 1499, "love": 57, "care": 6, "haha": 1, "wow": 1, "sad": 0, "angry": 0 },
    "author": {
        "id": "100077308612555",
        "name": "Business Insider Africa",
        "url": "https://www.facebook.com/businessinsiderssa",
        "profile_picture_url": "https://scontent.xx.fbcdn.net/..."
    },
    "image": { "uri": "https://scontent.xx.fbcdn.net/...", "height": 1350, "width": 1080, "id": "971562895430655" },
    "video": null,
    "video_view_count": null,
    "video_thumbnail": null,
    "external_url": null,
    "attached_post": null,
    "attached_post_url": null,
    "associated_group": null,
    "searchQuery": "climate change",
    "scrapedAt": "2026-07-03T14:06:01.794Z"
}
```

#### Field reference

| Field                            | Description                                                        |
| -------------------------------- | ------------------------------------------------------------------ |
| `post_id`                        | Facebook's unique ID for the post.                                 |
| `url`                            | Direct link to the post.                                           |
| `message` / `message_rich`       | The post text.                                                     |
| `timestamp`                      | Publish time, Unix seconds (UTC).                                  |
| `reactions_count`                | Total reactions.                                                   |
| `reactions`                      | Breakdown by type (like, love, care, haha, wow, sad, angry).       |
| `comments_count` / `reshare_count` | Comment and share totals.                                        |
| `author`                         | Poster's id, name, profile URL and picture.                        |
| `image` / `video` / `video_thumbnail` | Attached media, when present.                                 |
| `external_url`                   | Outbound link shared in the post, when present.                    |
| `attached_post` / `attached_post_url` | The original post, when this is a share.                      |
| `associated_group`               | The group the post belongs to, when applicable.                    |
| `searchQuery`                    | Which of your keywords surfaced this post.                         |
| `scrapedAt`                      | When the record was collected (ISO 8601).                          |

You can export the dataset as **JSON, CSV, Excel, HTML or RSS** from the run's **Storage** tab, or fetch it via the Apify API.

### Authentication (required)

Facebook does not allow searching posts without being logged in, so the scraper needs a Facebook session. Use a **dedicated throwaway account**, never your personal one. There are two ways to provide it:

#### Option A — automated login (easiest)

Set your account credentials and let the scraper log in for you:

- `fbEmail` and `fbPassword` in the input, **or** (recommended) as the `FB_EMAIL` and `FB_PASSWORD` environment variables on the actor.

The scraper logs in once, reuses the session on later runs, and re-authenticates automatically when it expires.

> The account **must have two-factor authentication turned off**, and should be logged in once from a normal browser (in the same country as your proxy) before its first run, so Facebook doesn't flag it as suspicious.

#### Option B — session cookies

Provide cookies from an already-logged-in session in the `cookies` input:

1. Log into your throwaway account in a browser.
2. Install the [Cookie-Editor](https://cookie-editor.com/) extension, open facebook.com, and **Export → JSON**.
3. Paste the exported array into the `cookies` field. Make sure it includes the `c_user` and `xs` cookies.

### Proxy

Facebook blocks most datacenter IPs. Keep the proxy on **Residential** (the default) and, ideally, in the same country as your account for the most reliable results.

### Tips & limitations

- **Quotes matter.** `"exact phrase"` matches that phrase; unquoted multi-word keywords match more loosely.
- **`maxResults` is per keyword.** Ten keywords at `maxResults: 50` targets up to 500 posts (minus duplicates).
- **Only public posts** that appear in Facebook search are returned; content from private profiles and closed groups is not accessible.
- **Availability depends on Facebook.** Facebook changes its site frequently and may throttle heavy activity; using recent, warmed-up accounts and residential proxies gives the most stable results.

### Support

Found a bug or need a field added? Open an issue or email **m83588864@gmail.com** and we'll take a look.

# Actor input Schema

## `query` (type: `string`):

One keyword/phrase to search for. Wrap in double quotes for an exact phrase match, e.g. "econet revenue". You can also paste several keywords, one per line, to search them all. For a clean list use the "queries" field below instead. Leave empty if you use "queries".

## `queries` (type: `array`):

Multiple keywords/phrases to search — each is searched separately and results are combined and de-duplicated by post. Takes precedence over/adds to "query". Each item can be wrapped in double quotes for exact-phrase matching. maxResults applies PER keyword.

## `recent_posts` (type: `boolean`):

Whether to only search for recent posts.

## `location_uid` (type: `string`):

Location unique identifier for filtering posts.

## `start_date` (type: `string`):

Start date for filtering posts (format: yyyy-mm-dd).

## `end_date` (type: `string`):

End date for filtering posts (format: yyyy-mm-dd).

## `maxResults` (type: `integer`):

Maximum number of posts to fetch.

## `cookies` (type: `array`):

Cookies of a logged-in Facebook session, exported with a browser extension such as Cookie-Editor or EditThisCookie (JSON array of {name, value, domain, ...}). REQUIRED in practice: Facebook returns HTTP 400 for anonymous post search. Alternatively set the FB\_COOKIES secret environment variable on the actor (same JSON, or a 'name=value; name2=value2' string) to avoid passing cookies in every run. Use a throwaway account, never your personal one.

## `fbEmail` (type: `string`):

Email/phone of a throwaway Facebook account. If set together with fbPassword (or via the FB\_EMAIL/FB\_PASSWORD secret env vars), the actor logs in itself and caches the session, so you don't need to paste cookies. The account must have 2FA disabled. Prefer setting these as secret environment variables on the actor rather than per run.

## `fbPassword` (type: `string`):

Password for the account in fbEmail. Stored encrypted. Prefer the FB\_PASSWORD secret environment variable instead of putting it in run input.

## `proxySessionId` (type: `string`):

Set a stable id here (or via the FB\_PROXY\_SESSION env var) to keep the account on ONE exit IP across runs. Facebook invalidates sessions that appear to hop IPs/regions, so pinning the IP — together with this actor writing the refreshed cookies back after every run — is what stops the session expiring. Use one distinct id per Facebook account, e.g. "acct1". Leave empty to use a fresh random IP each run (not recommended when reusing a session).

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

Proxy to route traffic through. Residential proxies are strongly recommended for Facebook, with a country set — the random global residential pool often hands out dead exit IPs, so the actor defaults RESIDENTIAL to US exits when no country is chosen. For a non-expiring session, keep apifyProxyCountry fixed to the account's usual region.

## `headless` (type: `boolean`):

Uncheck to run a headed browser (useful only for local debugging).

## Actor input object example

```json
{
  "queries": [],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "headless": 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 = {
    "queries": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("outspoken_strategy/facebook-post-search-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 = {
    "queries": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("outspoken_strategy/facebook-post-search-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 '{
  "queries": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call outspoken_strategy/facebook-post-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=outspoken_strategy/facebook-post-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "facebook-posts-search",
        "description": "Search Facebook posts by keyword with recent-posts, location and date-range filters. Drop-in replacement for powerai/facebook-post-search-scraper (identical input and output schema).",
        "version": "0.0",
        "x-build-id": "GUPaxoCPskDKQmwwo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/outspoken_strategy~facebook-post-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-outspoken_strategy-facebook-post-search-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/outspoken_strategy~facebook-post-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-outspoken_strategy-facebook-post-search-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/outspoken_strategy~facebook-post-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-outspoken_strategy-facebook-post-search-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": {
                    "query": {
                        "title": "Search Query (single keyword)",
                        "type": "string",
                        "description": "One keyword/phrase to search for. Wrap in double quotes for an exact phrase match, e.g. \"econet revenue\". You can also paste several keywords, one per line, to search them all. For a clean list use the \"queries\" field below instead. Leave empty if you use \"queries\"."
                    },
                    "queries": {
                        "title": "Search Queries (multiple keywords)",
                        "type": "array",
                        "description": "Multiple keywords/phrases to search — each is searched separately and results are combined and de-duplicated by post. Takes precedence over/adds to \"query\". Each item can be wrapped in double quotes for exact-phrase matching. maxResults applies PER keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recent_posts": {
                        "title": "Recent Posts Only",
                        "type": "boolean",
                        "description": "Whether to only search for recent posts."
                    },
                    "location_uid": {
                        "title": "Location UID",
                        "type": "string",
                        "description": "Location unique identifier for filtering posts."
                    },
                    "start_date": {
                        "title": "Start Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Start date for filtering posts (format: yyyy-mm-dd)."
                    },
                    "end_date": {
                        "title": "End Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "End date for filtering posts (format: yyyy-mm-dd)."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of posts to fetch.",
                        "default": 10
                    },
                    "cookies": {
                        "title": "Facebook session cookies",
                        "type": "array",
                        "description": "Cookies of a logged-in Facebook session, exported with a browser extension such as Cookie-Editor or EditThisCookie (JSON array of {name, value, domain, ...}). REQUIRED in practice: Facebook returns HTTP 400 for anonymous post search. Alternatively set the FB_COOKIES secret environment variable on the actor (same JSON, or a 'name=value; name2=value2' string) to avoid passing cookies in every run. Use a throwaway account, never your personal one."
                    },
                    "fbEmail": {
                        "title": "Facebook email (automated login)",
                        "type": "string",
                        "description": "Email/phone of a throwaway Facebook account. If set together with fbPassword (or via the FB_EMAIL/FB_PASSWORD secret env vars), the actor logs in itself and caches the session, so you don't need to paste cookies. The account must have 2FA disabled. Prefer setting these as secret environment variables on the actor rather than per run."
                    },
                    "fbPassword": {
                        "title": "Facebook password (automated login)",
                        "type": "string",
                        "description": "Password for the account in fbEmail. Stored encrypted. Prefer the FB_PASSWORD secret environment variable instead of putting it in run input."
                    },
                    "proxySessionId": {
                        "title": "Pinned proxy session id (keeps the session alive)",
                        "type": "string",
                        "description": "Set a stable id here (or via the FB_PROXY_SESSION env var) to keep the account on ONE exit IP across runs. Facebook invalidates sessions that appear to hop IPs/regions, so pinning the IP — together with this actor writing the refreshed cookies back after every run — is what stops the session expiring. Use one distinct id per Facebook account, e.g. \"acct1\". Leave empty to use a fresh random IP each run (not recommended when reusing a session)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy to route traffic through. Residential proxies are strongly recommended for Facebook, with a country set — the random global residential pool often hands out dead exit IPs, so the actor defaults RESIDENTIAL to US exits when no country is chosen. For a non-expiring session, keep apifyProxyCountry fixed to the account's usual region.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    },
                    "headless": {
                        "title": "Run browser headless",
                        "type": "boolean",
                        "description": "Uncheck to run a headed browser (useful only for local debugging).",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
