# We Work Remotely Jobs Scraper (`scrapeworks/weworkremotely-jobs-scraper`) Actor

Scrape remote job listings from We Work Remotely (weworkremotely.com): title, company, category, job type, location, skills, company website, apply URL, posted date and full description. Export the whole board or filter by category and keywords in bulk - one clean row per job.

- **URL**: https://apify.com/scrapeworks/weworkremotely-jobs-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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

## We Work Remotely Jobs Scraper

**Scrape remote job listings from [We Work Remotely](https://weworkremotely.com) (weworkremotely.com) into clean, structured data.** Pull the whole live board or filter by category and keywords in bulk — one tidy row per job with the title, company, category, job type, location, skills, company website, apply URL, posted date and the full job description.

We Work Remotely is one of the largest remote-work job boards. This actor turns its listings into a spreadsheet/JSON dataset you can search, filter, dedupe and load anywhere — no login, no API key, no browser needed.

### What you get (data fields)

| Field | Description |
|---|---|
| `title` | Job title (e.g. "Senior Full-Stack Developer") |
| `company` | Hiring company name |
| `companyLogo` | Company logo image URL |
| `category` | We Work Remotely category (e.g. "Full-Stack Programming", "Design") |
| `jobType` | Employment type — "Full-Time", "Contract", "Part-Time" |
| `region` | Where the role is open — "Anywhere in the World" or a country/state |
| `country` / `state` | Country / state when the listing specifies one |
| `skills` | List of skills/tags the company tagged (when the listing provides them) |
| `headquarters` | Company headquarters location |
| `companyUrl` | Company website (when the listing provides one) |
| `url` | We Work Remotely job posting URL (apply here) |
| `guid` | Stable unique job identifier (used for de-duplication) |
| `publishedAt` | When the job was posted |
| `expiresAt` | When the listing expires |
| `description` | Full job description as clean plain text |
| `descriptionHtml` | Full job description as raw HTML |
| `sourceCategory` | The category feed this row came from (`null` = whole-board feed) |
| `scrapedAt` | Timestamp of the scrape (ISO 8601) |

### How it works

We Work Remotely publishes public RSS feeds — the whole-board feed and one feed per category — so the actor reads structured data straight from the source, never fragile page selectors. It fetches one feed per category you list plus the whole-board feed, then **merges and de-duplicates by job**, so a broad category list pulls essentially the entire active board in a single run and you're never charged twice for the same posting.

> **Note on field coverage:** the whole-board feed and the individual category feeds carry the same fields, with **one exception** — the broad **`remote-programming-jobs`** feed is a leaner aggregate that omits `jobType`, `skills`, `country`/`state` and `expiresAt`. Those jobs still come through in full via the whole-board feed and the specific `remote-full-stack-programming-jobs` / `remote-front-end-programming-jobs` / `remote-back-end-programming-jobs` feeds, so keeping **"Also scrape the whole-board feed"** on (the default) guarantees every job gets the full field set. Separately, a handful of fields — `companyLogo`, `companyUrl`, `skills`, `country`/`state` — are only filled when the individual company provided them, so they're populated on some rows and empty on others regardless of which feed a row came from.

### Input

Everything is optional — run it with the defaults to grab the whole board. Example:

```json
{
  "categories": [
    "remote-programming-jobs",
    "remote-design-jobs",
    "remote-customer-support-jobs",
    "all-other-remote-jobs"
  ],
  "includeMainFeed": true,
  "searchTerms": ["senior", "react", "python"],
  "jobTypes": ["Full-Time"],
  "maxResults": 1000
}
````

- **categories** — category feeds to scrape (leave empty to scrape only the whole-board feed). Valid slugs: `remote-full-stack-programming-jobs`, `remote-front-end-programming-jobs`, `remote-back-end-programming-jobs`, `remote-programming-jobs`, `remote-devops-sysadmin-jobs`, `remote-design-jobs`, `remote-customer-support-jobs`, `remote-sales-and-marketing-jobs`, `remote-management-and-finance-jobs`, `remote-product-jobs`, `all-other-remote-jobs`.
- **includeMainFeed** — also fetch the whole-board feed of the newest jobs across every category (default `true`; guarantees the full field set even for jobs found only via the leaner `remote-programming-jobs` feed).
- **searchTerms** — optional keywords; a job is kept if it matches **any** term (case-insensitive) in its title, company, category, region or description.
- **jobTypes** — optional list, e.g. `["Full-Time", "Contract"]`.
- **maxResults** — cap on the number of unique jobs returned (billed per row).
- **proxyConfiguration** — Apify Residential proxy is used only as a fallback if a request is blocked.

### Output sample

```json
{
  "title": "Data Governance & Platform Manager",
  "company": "LawnStarter",
  "companyLogo": "https://wwr-pro.s3.amazonaws.com/logos/0171/5865/logo.gif",
  "category": "All Other Remote",
  "jobType": "Full-Time",
  "region": "Anywhere in the World",
  "country": null,
  "state": null,
  "skills": [],
  "headquarters": "Brazil",
  "companyUrl": "http://lawnstarter.com",
  "url": "https://weworkremotely.com/remote-jobs/lawnstarter-data-governance-platform-manager",
  "guid": "https://weworkremotely.com/remote-jobs/lawnstarter-data-governance-platform-manager",
  "publishedAt": "Fri, 17 Jul 2026 20:07:06 +0000",
  "expiresAt": "Sun, 16 Aug 2026 20:07:06 +0000",
  "description": "Headquarters: Brazil\nURL: http://lawnstarter.com\n\nAbout LawnStarter ...",
  "sourceCategory": null,
  "scrapedAt": "2026-07-20T00:00:00Z"
}
```

### Use cases

- **Job aggregators & niche boards** — feed a curated remote-jobs site or newsletter with fresh listings.
- **Recruiting & sourcing** — monitor which companies are hiring remotely and in which categories.
- **Market & hiring research** — track remote-hiring trends, in-demand skills, employment types and company locations over time.
- **Lead generation** — build a list of companies actively hiring (with their websites) for outreach.

### FAQ

**Do I need an account or API key for We Work Remotely?** No. The actor reads public RSS feeds — no login required.

**How many jobs will I get?** The feeds return We Work Remotely's live listings across the selected categories. Merged and de-duplicated, a full run pulls essentially the whole active board (typically a few hundred unique jobs). Use `maxResults` to cap it.

**Why are `skills`, `country`/`state` or `companyLogo` sometimes empty?** Those fields are only filled when the individual company provided them — not every listing does — so they appear on some rows and not others (this is the same on the whole-board and category feeds, it's a per-listing gap, not a feed limitation). Core fields like `jobType`, `region` and `expiresAt` are present on essentially every row; the one exception is the broad `remote-programming-jobs` aggregate feed, which is leaner — keep **includeMainFeed** on (the default) so those jobs still come through with the full data.

**Can I filter to specific roles?** Yes — add keywords to `searchTerms` (matches any term) and/or narrow `jobTypes`.

**Is it billed per job?** Yes — pay-per-result: you're charged once per unique job row returned. Duplicate postings across categories are removed before billing.

# Actor input Schema

## `categories` (type: `array`):

We Work Remotely category feeds to scrape. One RSS feed is fetched per category and merged, so more categories = more jobs (duplicates across categories are removed automatically). Each feed returns that category's most-recent live jobs, so the default list pulls essentially the whole active board in one run. Valid slugs: 'remote-full-stack-programming-jobs', 'remote-front-end-programming-jobs', 'remote-back-end-programming-jobs', 'remote-programming-jobs', 'remote-devops-sysadmin-jobs', 'remote-design-jobs', 'remote-customer-support-jobs', 'remote-sales-and-marketing-jobs', 'remote-management-and-finance-jobs', 'remote-product-jobs', 'all-other-remote-jobs'. Leave empty to scrape only the whole-board feed below.

## `includeMainFeed` (type: `boolean`):

If enabled (default), the actor also fetches We Work Remotely's whole-board feed (the most-recently posted jobs across every category) in addition to the category feeds above. Turn this off to scrape ONLY the categories you listed. If you list no categories, the whole-board feed is always fetched.

## `searchTerms` (type: `array`):

Optional list of keywords. When set, only jobs whose title, company, category or description contains ANY of these terms (case-insensitive) are kept - e.g. 'react', 'senior', 'python', 'customer support', 'designer'. Pass several terms to widen the net (matches ANY, not ALL). Leave empty to keep every job in the selected categories.

## `jobTypes` (type: `array`):

Optional list of job types to keep, matched case-insensitively against the listing's type - e.g. 'Full-Time', 'Contract', 'Part-Time'. Leave empty to keep every job type.

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

Maximum number of unique jobs to return for the whole run (across all categories, after removing duplicates). Results are billed per job row. Lower it to cap cost on a test run.

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

Proxy used to reach weworkremotely.com. The actor fetches directly first (cheapest) and only falls back to this proxy, rotating to a fresh session, if a response comes back blocked. The default (Apify Residential, US) is a safe fallback.

## Actor input object example

```json
{
  "categories": [
    "remote-programming-jobs",
    "remote-design-jobs",
    "remote-customer-support-jobs"
  ],
  "includeMainFeed": true,
  "searchTerms": [
    "react",
    "senior",
    "python"
  ],
  "jobTypes": [
    "Full-Time",
    "Contract"
  ],
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "categories": [
        "remote-full-stack-programming-jobs",
        "remote-front-end-programming-jobs",
        "remote-back-end-programming-jobs",
        "remote-programming-jobs",
        "remote-devops-sysadmin-jobs",
        "remote-design-jobs",
        "remote-customer-support-jobs",
        "remote-sales-and-marketing-jobs",
        "remote-management-and-finance-jobs",
        "remote-product-jobs",
        "all-other-remote-jobs"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/weworkremotely-jobs-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 = {
    "categories": [
        "remote-full-stack-programming-jobs",
        "remote-front-end-programming-jobs",
        "remote-back-end-programming-jobs",
        "remote-programming-jobs",
        "remote-devops-sysadmin-jobs",
        "remote-design-jobs",
        "remote-customer-support-jobs",
        "remote-sales-and-marketing-jobs",
        "remote-management-and-finance-jobs",
        "remote-product-jobs",
        "all-other-remote-jobs",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/weworkremotely-jobs-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 '{
  "categories": [
    "remote-full-stack-programming-jobs",
    "remote-front-end-programming-jobs",
    "remote-back-end-programming-jobs",
    "remote-programming-jobs",
    "remote-devops-sysadmin-jobs",
    "remote-design-jobs",
    "remote-customer-support-jobs",
    "remote-sales-and-marketing-jobs",
    "remote-management-and-finance-jobs",
    "remote-product-jobs",
    "all-other-remote-jobs"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapeworks/weworkremotely-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "We Work Remotely Jobs Scraper",
        "description": "Scrape remote job listings from We Work Remotely (weworkremotely.com): title, company, category, job type, location, skills, company website, apply URL, posted date and full description. Export the whole board or filter by category and keywords in bulk - one clean row per job.",
        "version": "0.1",
        "x-build-id": "r9FotaWu9b9cWr3BH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~weworkremotely-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-weworkremotely-jobs-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/scrapeworks~weworkremotely-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-weworkremotely-jobs-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/scrapeworks~weworkremotely-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-weworkremotely-jobs-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": {
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "We Work Remotely category feeds to scrape. One RSS feed is fetched per category and merged, so more categories = more jobs (duplicates across categories are removed automatically). Each feed returns that category's most-recent live jobs, so the default list pulls essentially the whole active board in one run. Valid slugs: 'remote-full-stack-programming-jobs', 'remote-front-end-programming-jobs', 'remote-back-end-programming-jobs', 'remote-programming-jobs', 'remote-devops-sysadmin-jobs', 'remote-design-jobs', 'remote-customer-support-jobs', 'remote-sales-and-marketing-jobs', 'remote-management-and-finance-jobs', 'remote-product-jobs', 'all-other-remote-jobs'. Leave empty to scrape only the whole-board feed below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeMainFeed": {
                        "title": "Also scrape the whole-board feed",
                        "type": "boolean",
                        "description": "If enabled (default), the actor also fetches We Work Remotely's whole-board feed (the most-recently posted jobs across every category) in addition to the category feeds above. Turn this off to scrape ONLY the categories you listed. If you list no categories, the whole-board feed is always fetched.",
                        "default": true
                    },
                    "searchTerms": {
                        "title": "Keyword filter (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional list of keywords. When set, only jobs whose title, company, category or description contains ANY of these terms (case-insensitive) are kept - e.g. 'react', 'senior', 'python', 'customer support', 'designer'. Pass several terms to widen the net (matches ANY, not ALL). Leave empty to keep every job in the selected categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTypes": {
                        "title": "Job types (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional list of job types to keep, matched case-insensitively against the listing's type - e.g. 'Full-Time', 'Contract', 'Part-Time'. Leave empty to keep every job type.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of unique jobs to return for the whole run (across all categories, after removing duplicates). Results are billed per job row. Lower it to cap cost on a test run.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach weworkremotely.com. The actor fetches directly first (cheapest) and only falls back to this proxy, rotating to a fresh session, if a response comes back blocked. The default (Apify Residential, US) is a safe fallback.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
