# RemoteOK Jobs Scraper (`fetch_cat/remoteok-jobs-scraper`) Actor

Scrape public RemoteOK remote job listings by skill tags, keywords, location text, salary range, and date. Export company, role, tags, salary, apply URL, source URL, and optional descriptions.

- **URL**: https://apify.com/fetch\_cat/remoteok-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 job extracteds

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## RemoteOK Jobs Scraper

Scrape public RemoteOK remote job listings into a clean Apify dataset.

Use this actor to monitor new remote roles, collect job-market signals, enrich recruiting workflows, and build job-board feeds from RemoteOK listings.

### Scrape RemoteOK remote jobs by skill, location, salary, and date

RemoteOK Jobs Scraper extracts structured remote job data from RemoteOK.

It saves job rows with company, title, tags, location, salary range, apply link, source link, logo, and scrape timestamp.

You can filter jobs by skills, keywords, location text, salary range, posting date, and maximum item count.

The actor is designed for repeatable monitoring jobs where you need spreadsheet-ready results without manual browsing.

### Who is it for?

Recruiters use it to track newly posted remote roles by stack, seniority, market, or company segment.

Job-board operators use it to populate newsletters, dashboards, and niche remote-work directories.

Market analysts use it to study remote hiring demand, salary ranges, hiring companies, and skill tags.

Lead-generation teams use it to find hiring companies and open roles that indicate buying intent.

Developers use it to automate remote-job feeds and integrate RemoteOK listings with their own systems.

### Why use this actor?

Remote job listings change quickly.

Manual copy-paste is slow and error-prone.

This actor gives you structured rows that are ready for export, automation, and API use.

It supports precise filters so you can keep runs small and focused.

It also includes source URLs so each row can be verified from the original listing.

### Key features

- 🎯 Filter by tags or skills such as `python`, `react`, `sales`, or `marketing`.
- 🔎 Add free-text keywords for title, company, tag, location, or description matches.
- 🌍 Filter by location text such as `USA`, `Europe`, `Worldwide`, or `Canada`.
- 💰 Filter by minimum and maximum reported salary ranges.
- 📅 Keep only jobs posted after a chosen date.
- 🧾 Optionally include job descriptions for richer analysis.
- 🔗 Export direct apply and source URLs.
- ⚡ Keep costs low with a maximum job limit.

### RemoteOK fields you can export

| Field | Description |
| --- | --- |
| `id` | RemoteOK job identifier. |
| `slug` | RemoteOK job slug. |
| `date` | Posting date when available. |
| `company` | Hiring company name. |
| `position` | Job title or role. |
| `tags` | Skills and categories attached to the listing. |
| `description` | Optional job description HTML. |
| `location` | Location text from the listing. |
| `salaryMin` | Lower salary bound when available. |
| `salaryMax` | Upper salary bound when available. |
| `applyUrl` | Direct apply or listing URL. |
| `sourceUrl` | Source job page URL. |
| `logo` | Company logo URL when available. |
| `scrapedAt` | Timestamp when the actor saved the row. |

### Use as an RSS feed

You can turn the latest dataset items from a saved Apify task into an RSS feed. Create an actor task with your preferred input, then use the task's last-run dataset endpoint with `format=rss`, `fields`, and `outputFields`:

```text
https://api.apify.com/v2/actor-tasks/[TASK_ID]/runs/last/dataset/items?format=rss&fields=position,sourceUrl,description,date&outputFields=title,link,description,pubDate&token=[APIFY_TOKEN]
````

Use the `fields` list to select this actor's dataset columns, and `outputFields` to map them to RSS item fields such as `title`, `link`, `description`, and `pubDate`. Keep your Apify API token private; do not embed tokenized feed URLs in public websites, public repositories, or client-side code.

### How much does it cost to scrape RemoteOK jobs?

This actor uses pay-per-result pricing.

You pay a small start fee plus a small amount for each saved job row.

The default prefilled run is intentionally small so first tests stay inexpensive.

For large monitoring workflows, use filters and date limits to keep exports focused.

Final platform pricing is visible on the Apify actor page before you start a run.

### Input options

| Input | Type | Example | Notes |
| --- | --- | --- | --- |
| `tags` | array | `["python", "react"]` | Matches skills or terms across job text. |
| `keywords` | array | `["backend"]` | Extra free-text filters. |
| `location` | string | `USA` | Contains-match against location text. |
| `sinceDate` | string | `2026-06-01` | Use `YYYY-MM-DD`. |
| `minSalary` | integer | `100000` | Jobs without salary are excluded when set. |
| `maxSalary` | integer | `180000` | Leave `0` to disable. |
| `maxItems` | integer | `25` | Maximum matching jobs to save. |
| `includeDescription` | boolean | `false` | Enable for richer but larger rows. |

### Example input

```json
{
  "tags": ["python", "react"],
  "keywords": [],
  "location": "",
  "sinceDate": "",
  "minSalary": 0,
  "maxSalary": 0,
  "maxItems": 20,
  "includeDescription": false
}
```

### Example output

```json
{
  "id": "1133690",
  "slug": "remote-example-role-1133690",
  "date": "2026-06-19T00:03:05+00:00",
  "company": "Example Company",
  "position": "Remote Software Engineer",
  "tags": ["python", "react"],
  "location": "Worldwide",
  "salaryMin": 100000,
  "salaryMax": 160000,
  "applyUrl": "https://remoteok.com/remote-jobs/example",
  "sourceUrl": "https://remoteok.com/remote-jobs/example",
  "logo": "https://remoteok.com/assets/example.png",
  "scrapedAt": "2026-06-20T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Add skills or tags you care about.
3. Optionally add location, salary, or date filters.
4. Set `maxItems` to the number of matching jobs you want.
5. Click **Start**.
6. Download results as JSON, CSV, Excel, XML, or HTML.

### Tips for better results

Use broad tags for market research.

Use narrow tags for recruiting alerts.

Leave `location` empty when you want all remote roles.

Use `sinceDate` for recurring daily or weekly monitoring.

Enable `includeDescription` only when you need full job text.

If a salary filter returns few rows, remember many listings do not publish salary ranges.

### Common use cases

- Track remote engineering jobs by programming language.
- Build a weekly remote-work newsletter.
- Monitor salary bands for remote roles.
- Identify companies hiring remote workers.
- Enrich CRM accounts with hiring signals.
- Compare demand across skill tags.
- Feed dashboards with current job-market data.

### Integrations

Connect the actor to Google Sheets for recurring remote-job feeds.

Use scheduled tasks plus RSS/API exports for newsletters, remote-job boards, dashboards, and hiring-signal alerts.

Send results to Slack or email through Apify integrations.

Store data in a database or warehouse by pulling dataset items from the Apify API.

Trigger runs from Zapier, Make, n8n, MCP, or your own scheduler.

Combine results with enrichment actors to profile hiring companies.

### API usage

You can start the actor from any HTTP client using the Apify API.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/remoteok-jobs-scraper').call({
  tags: ['python'],
  maxItems: 20,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/remoteok-jobs-scraper').call(run_input={
    'tags': ['python'],
    'maxItems': 20,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~remoteok-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"tags":["python"],"maxItems":20}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/remoteok-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-remoteok --transport http "https://mcp.apify.com/?tools=fetch_cat/remoteok-jobs-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-remoteok": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/remoteok-jobs-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

```text
Run fetch_cat/remoteok-jobs-scraper for Python remote jobs, max 20 items, and summarize the top companies hiring.
```

```text
Find RemoteOK jobs tagged React since this month and group the results by location.
```

Workflow prompt:

```text
Use the RemoteOK scraper to find recent customer support jobs and prepare a CSV-ready table with company, title, location, salary, and apply URL.
```

### Scheduling

For monitoring, schedule the actor daily or weekly.

Use `sinceDate` to limit each recurring run to recent jobs.

Export only new rows by comparing `id` values in your destination system.

### Data quality notes

Salary fields are available only when RemoteOK provides salary bounds.

Locations are free-text and may include broad regions such as Worldwide or Europe.

Descriptions can include HTML formatting.

Source links are included so you can inspect the original job page.

### Limits

The actor caps `maxItems` at 1000 per run.

If filters are too strict, the dataset may contain fewer jobs than requested.

Remote job boards can remove or update listings after they are scraped.

### FAQ and troubleshooting

#### Can I scrape RemoteOK jobs with salary ranges?

Yes. The actor returns `salaryMin` and `salaryMax` when RemoteOK publishes salary bounds, and you can filter by minimum or maximum salary.

#### Can I filter RemoteOK jobs by skill tags?

Yes. Use `tags` for skills or categories such as `python`, `react`, `sales`, or `marketing`, and combine them with keyword, location, date, and salary filters.

#### Why do salary filters return fewer jobs?

Many listings do not publish salary ranges. When salary filters are set, listings without salary values are excluded.

#### Why did I get zero results?

Your filters may be too narrow.

Remove salary filters, clear location, or use fewer tags.

#### Why are salary fields empty?

Many remote jobs do not publish salary ranges.

Rows without salary are saved unless you set salary filters.

#### Why is the description missing?

Set `includeDescription` to `true` if you need the description field.

### Legality and responsible use

This actor extracts publicly available job listing information.

Use the data responsibly and follow RemoteOK terms, Apify terms, and applicable laws.

Do not use scraped data for spam, fraud, or discriminatory hiring practices.

### Related actors and scrapers

- [Remotive Jobs Scraper](https://apify.com/fetch_cat/remotive-jobs-scraper) for another remote-job source.
- [LinkedIn Jobs Scraper](https://apify.com/fetch_cat/linkedin-jobs-scraper) for broader public job-market coverage.
- [Greenhouse Jobs Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper) for company ATS boards.
- [Y Combinator Companies Scraper](https://apify.com/fetch_cat/y-combinator-companies-scraper) for startup companies that are hiring.
- [Web Page to Markdown Extractor](https://apify.com/fetch_cat/web-page-to-markdown-extractor) for enriching apply or source pages when needed.

### Support

If a run fails or returns unexpected data, open an issue on the actor page with the run ID.

Include your input and a short description of what you expected.

### Changelog

Initial version extracts public RemoteOK job listings with filters for tags, keywords, location, salary, date, max items, and optional descriptions.

# Actor input Schema

## `tags` (type: `array`):

Skill tags or terms to match, such as python, react, marketing, or customer support. Leave empty for all jobs.

## `keywords` (type: `array`):

Additional free-text keywords to match in title, company, tags, location, or description.

## `location` (type: `string`):

Only keep jobs whose RemoteOK location text contains this value, e.g. USA, Europe, Worldwide, Canada.

## `sinceDate` (type: `string`):

Only keep jobs posted on or after this date. Use YYYY-MM-DD format.

## `minSalary` (type: `integer`):

Only keep jobs whose reported salary range reaches at least this annual USD amount. Jobs without salary are excluded when this is set.

## `maxSalary` (type: `integer`):

Only keep jobs whose reported salary range starts at or below this annual USD amount. Leave 0 to disable.

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

Maximum number of matching job rows to save.

## `includeDescription` (type: `boolean`):

Include RemoteOK's HTML job description in each dataset item. Disable for smaller, cleaner exports.

## Actor input object example

```json
{
  "tags": [
    "python",
    "react"
  ],
  "keywords": [],
  "maxItems": 20,
  "includeDescription": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "tags": [
        "python",
        "react"
    ],
    "keywords": [],
    "location": "",
    "sinceDate": "",
    "minSalary": 0,
    "maxSalary": 0,
    "maxItems": 20,
    "includeDescription": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/remoteok-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 = {
    "tags": [
        "python",
        "react",
    ],
    "keywords": [],
    "location": "",
    "sinceDate": "",
    "minSalary": 0,
    "maxSalary": 0,
    "maxItems": 20,
    "includeDescription": False,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/remoteok-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 '{
  "tags": [
    "python",
    "react"
  ],
  "keywords": [],
  "location": "",
  "sinceDate": "",
  "minSalary": 0,
  "maxSalary": 0,
  "maxItems": 20,
  "includeDescription": false
}' |
apify call fetch_cat/remoteok-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RemoteOK Jobs Scraper",
        "description": "Scrape public RemoteOK remote job listings by skill tags, keywords, location text, salary range, and date. Export company, role, tags, salary, apply URL, source URL, and optional descriptions.",
        "version": "0.1",
        "x-build-id": "It7C1ADzBkzEaQHND"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~remoteok-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-remoteok-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/fetch_cat~remoteok-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-remoteok-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/fetch_cat~remoteok-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-remoteok-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": {
                    "tags": {
                        "title": "Tags or skills",
                        "type": "array",
                        "description": "Skill tags or terms to match, such as python, react, marketing, or customer support. Leave empty for all jobs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Additional free-text keywords to match in title, company, tags, location, or description.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location contains",
                        "type": "string",
                        "description": "Only keep jobs whose RemoteOK location text contains this value, e.g. USA, Europe, Worldwide, Canada."
                    },
                    "sinceDate": {
                        "title": "Posted since date",
                        "type": "string",
                        "description": "Only keep jobs posted on or after this date. Use YYYY-MM-DD format."
                    },
                    "minSalary": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep jobs whose reported salary range reaches at least this annual USD amount. Jobs without salary are excluded when this is set."
                    },
                    "maxSalary": {
                        "title": "Maximum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep jobs whose reported salary range starts at or below this annual USD amount. Leave 0 to disable."
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of matching job rows to save.",
                        "default": 50
                    },
                    "includeDescription": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Include RemoteOK's HTML job description in each dataset item. Disable for smaller, cleaner exports.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
