# Remote OK Jobs Scraper (`automation-lab/remoteok-jobs-scraper`) Actor

Scrape Remote OK jobs with tags, salaries, locations, descriptions, apply URLs, and fresh posting metadata for recruiting workflows.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

## Remote OK Jobs Scraper

Collect structured job listings from Remote OK for recruiting, labor-market research, newsletters, and job-board automation.

The actor reads Remote OK public JSON/listing endpoints and saves clean records with role, company, tags, location, salary range, description, apply URL, listing URL, and source metadata.

### What does Remote OK Jobs Scraper do?

Remote OK Jobs Scraper turns Remote OK listings into a clean Apify dataset.

It can:

- ✅ scrape all currently listed Remote OK jobs
- ✅ scrape a category page such as developer jobs
- ✅ filter by keyword, tag, posted date, and salary availability
- ✅ save salary ranges when Remote OK provides them
- ✅ save cleaned description text for downstream matching
- ✅ optionally preserve the original HTML description
- ✅ output apply links and listing links for each job
- ✅ run without a browser for fast, low-cost collection

### Who is it for?

Recruiting teams use the actor to monitor remote hiring activity and source roles in specific job categories.

Talent intelligence analysts use it to track which companies are hiring remotely, what skills appear in job tags, and how salary ranges move over time.

Remote-work newsletters use it to collect fresh openings for editorial review.

Job-board operators use it to enrich internal feeds and compare their inventory against Remote OK.

Developers and automation teams use it as a reliable Remote OK data source inside Apify, Make, Zapier, Airtable, Google Sheets, or custom pipelines.

### Why use this actor?

Remote OK pages are designed for browsing, not for repeatable analytics exports.

This actor gives you:

- 🚀 structured JSON instead of manual copy-paste
- 🧭 filters that keep runs focused and affordable
- 🔗 direct listing and apply URLs
- 💵 salary ranges as numeric fields
- 🧹 cleaned job-description text
- 📦 an Apify dataset ready for export or API use

### Data you can extract

| Field | Description |
| --- | --- |
| `jobId` | Remote OK job identifier |
| `title` | Job title |
| `companyName` | Hiring company |
| `companyLogo` | Company logo URL when available |
| `tags` | Remote OK tags on the listing |
| `category` | First tag, useful as a broad category |
| `location` | Location text from Remote OK |
| `isWorldwide` | Whether the listing appears worldwide/global |
| `salaryMin` | Minimum salary, when available |
| `salaryMax` | Maximum salary, when available |
| `currency` | Salary currency, currently USD |
| `postedAt` | Remote OK posting date |
| `descriptionText` | Cleaned text description |
| `descriptionHtml` | Optional original HTML description |
| `applyUrl` | Apply URL or Remote OK listing URL |
| `listingUrl` | Remote OK listing URL |
| `sourceUrl` | API/list page used for the record |
| `scrapedAt` | Timestamp of the scrape |

### How much does it cost to scrape Remote OK jobs?

This actor uses pay-per-event pricing.

You pay a $0.005 run-start fee plus a tiered per-job fee for saved listings.

The BRONZE per-job price is $0.000083 per saved job, with standard Apify tier discounts for higher-volume plans. Tier prices are FREE $0.0001, BRONZE $0.000083, SILVER $0.00006474, GOLD $0.0000498, PLATINUM $0.0000332, and DIAMOND $0.00002324.

Because the actor uses HTTP endpoints instead of a browser, compute usage is low and runs usually finish quickly.

### Quick start

1. Open the actor on Apify.
2. Keep the prefilled Remote OK developer jobs URL or add your own Remote OK URL.
3. Set `maxItems` to a small value for the first run.
4. Add tags or search terms if you want a focused dataset.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

#### `startUrls`

Optional Remote OK URLs to scrape.

Examples:

- `https://remoteok.com/api`
- `https://remoteok.com/remote-dev-jobs`
- `https://remoteok.com/remote-marketing-jobs`

If you enter a category page, the actor converts it to Remote OK's public `.json` endpoint.

#### `searchTerms`

Words that must appear in the title, company, tags, location, or description text.

Example:

```json
["engineer", "python"]
````

#### `tags`

Remote OK tags/categories that must be present on saved jobs.

Examples:

```json
["dev"]
```

```json
["marketing", "senior"]
```

#### `maxItems`

Maximum number of job listings to save.

Start with 25 for a quick test, then increase for monitoring or backfills.

#### `postedAfter`

Use `YYYY-MM-DD` to keep only newer jobs.

Example:

```json
"2026-05-01"
```

#### `salaryOnly`

Set to `true` to keep only jobs where Remote OK provides a salary range.

#### `includeDescriptionHtml`

Set to `true` when you need the original HTML formatting.

Keep it `false` when you only need compact, cleaned text.

### Example input

```json
{
  "startUrls": [
    { "url": "https://remoteok.com/remote-dev-jobs" }
  ],
  "searchTerms": ["engineer"],
  "tags": ["dev"],
  "maxItems": 25,
  "salaryOnly": false,
  "includeDescriptionHtml": false
}
```

### Example output

```json
{
  "jobId": "1132436",
  "title": "Events Marketing Manager",
  "companyName": "Pivotal Health",
  "companyLogo": null,
  "tags": ["exec", "design", "saas", "marketing"],
  "category": "exec",
  "location": "Los Angeles",
  "isWorldwide": false,
  "salaryMin": 105000,
  "salaryMax": 120000,
  "currency": "USD",
  "postedAt": "2026-05-28T08:00:02+00:00",
  "descriptionText": "About Pivotal Health...",
  "applyUrl": "https://remoteok.com/remote-jobs/...",
  "listingUrl": "https://remoteok.com/remote-jobs/...",
  "sourceUrl": "https://remoteok.com/remote-dev-jobs.json",
  "scrapedAt": "2026-05-29T09:00:00.000Z"
}
```

### Tips for better results

- 🎯 Use tags for precise Remote OK categories.
- 🔎 Use search terms for skills, tools, or company names.
- 💵 Enable salary-only mode when compensation analysis matters.
- 🧪 Test with `maxItems: 25` before running larger jobs.
- 🧾 Keep `includeDescriptionHtml` off unless you need raw formatting.

### Integrations

You can connect the dataset to:

- Google Sheets for recruiting dashboards
- Airtable for editorial review queues
- Make or Zapier for alerts and workflows
- BigQuery or Snowflake for labor-market analytics
- Slack or Discord bots for remote-job notifications
- Internal ATS enrichment pipelines

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/remoteok-jobs-scraper').call({
  startUrls: [{ url: 'https://remoteok.com/remote-dev-jobs' }],
  tags: ['dev'],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/remoteok-jobs-scraper').call(run_input={
    'startUrls': [{'url': 'https://remoteok.com/remote-dev-jobs'}],
    'tags': ['dev'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~remoteok-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://remoteok.com/remote-dev-jobs"}],"maxItems":25}'
```

### MCP usage

Use this actor through Apify MCP when you want Claude or another MCP client to fetch fresh Remote OK listings.

MCP endpoint:

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

Claude Code setup:

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

Claude Desktop JSON configuration:

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

Example prompts:

- "Find 20 Remote OK developer jobs with salary ranges."
- "Collect Remote OK marketing jobs and summarize the most common tags."
- "Monitor Remote OK for AI engineer roles posted after this week."

### Automation patterns

#### Recruiting monitor

Run daily with a fixed tag list and `postedAfter` set by your workflow.

#### Salary tracker

Run with `salaryOnly: true`, export salary fields, and chart ranges by tag.

#### Newsletter queue

Run with broad tags, review the dataset, then select listings for your audience.

#### Competitive intelligence

Track which companies repeatedly post remote roles and which skills appear most often.

### FAQ

#### Is this an official Remote OK API?

No. This actor is an independent Apify actor that reads public Remote OK job feeds and preserves Remote OK source URLs for attribution.

#### Can I scrape historical Remote OK jobs?

The actor returns the jobs available through Remote OK's current public feeds. It is best for recurring monitoring rather than deep historical backfills.

### Troubleshooting

#### My run returns fewer jobs than requested

Remote OK may not have enough current jobs matching all filters. Remove a search term, reduce required tags, or disable salary-only mode.

#### I do not see salary data for every job

Remote OK does not publish salary ranges for every listing. Use `salaryOnly` if you only want jobs with salary data.

#### A category URL returns no results

Check that the URL is a Remote OK listing page. The actor supports `remoteok.com` URLs and converts normal listing pages to `.json` endpoints.

### Data freshness

Remote OK updates its public job feeds continuously.

Each output row includes both `postedAt` from Remote OK and `scrapedAt` from the actor run so you can separate listing age from collection time.

### Performance

This is an HTTP-only actor.

It does not launch a browser.

Most small and medium runs should finish quickly because filtering happens locally after one JSON fetch per source URL.

### Legality

This actor collects publicly available Remote OK job listing information.

You are responsible for using the data in accordance with applicable law, Remote OK terms, privacy rules, and your own compliance requirements.

Do not use scraped data for spam, discrimination, or other prohibited recruiting practices.

### Related scrapers

Explore related actors from automation-lab:

- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-jobs-scraper
- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/company-enrichment-scraper

### Support

If a run fails or the output looks wrong, open an issue from the Apify run page and include:

- your input JSON
- expected filters
- run ID
- a sample listing URL if relevant

### Changelog

Initial version:

- HTTP scraping of Remote OK public JSON feeds
- keyword, tag, date, and salary filters
- cleaned job output with salary and URLs

### Responsible use

Remote OK asks API consumers to link back to Remote OK and mention Remote OK as a source.

This actor includes `listingUrl`, `applyUrl`, and `sourceUrl` fields so downstream products can preserve attribution and send users back to the original listing.

# Actor input Schema

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

Optional Remote OK URLs to scrape. Use https://remoteok.com/api for all jobs or a category page such as https://remoteok.com/remote-dev-jobs.

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

Optional words that must appear in the job title, company, tags, location, or description text.

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

Optional Remote OK tags/categories that each saved job must include, for example dev, marketing, sales, customer support, senior, or ai.

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

Maximum number of job listings to save.

## `postedAfter` (type: `string`):

Keep only jobs posted on or after this date. Use YYYY-MM-DD format. Leave empty to include all dates returned by Remote OK.

## `salaryOnly` (type: `boolean`):

If enabled, save only jobs with a non-zero salary range.

## `includeDescriptionHtml` (type: `boolean`):

Include Remote OK's original HTML job description in addition to cleaned text. This makes records larger but preserves formatting.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://remoteok.com/remote-dev-jobs"
    }
  ],
  "searchTerms": [
    "engineer"
  ],
  "tags": [
    "dev"
  ],
  "maxItems": 20,
  "salaryOnly": false,
  "includeDescriptionHtml": 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 = {
    "startUrls": [
        {
            "url": "https://remoteok.com/remote-dev-jobs"
        }
    ],
    "searchTerms": [
        "engineer"
    ],
    "tags": [
        "dev"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "startUrls": [{ "url": "https://remoteok.com/remote-dev-jobs" }],
    "searchTerms": ["engineer"],
    "tags": ["dev"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "startUrls": [
    {
      "url": "https://remoteok.com/remote-dev-jobs"
    }
  ],
  "searchTerms": [
    "engineer"
  ],
  "tags": [
    "dev"
  ],
  "maxItems": 20
}' |
apify call automation-lab/remoteok-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Remote OK Jobs Scraper",
        "description": "Scrape Remote OK jobs with tags, salaries, locations, descriptions, apply URLs, and fresh posting metadata for recruiting workflows.",
        "version": "0.1",
        "x-build-id": "gg6JXxmFc7DeQ51Uo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~remoteok-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~remoteok-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~remoteok-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "startUrls": {
                        "title": "Remote OK URLs",
                        "type": "array",
                        "description": "Optional Remote OK URLs to scrape. Use https://remoteok.com/api for all jobs or a category page such as https://remoteok.com/remote-dev-jobs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional words that must appear in the job title, company, tags, location, or description text.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "tags": {
                        "title": "Required tags",
                        "type": "array",
                        "description": "Optional Remote OK tags/categories that each saved job must include, for example dev, marketing, sales, customer support, senior, or ai.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save.",
                        "default": 20
                    },
                    "postedAfter": {
                        "title": "Posted after",
                        "pattern": "^$|^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Keep only jobs posted on or after this date. Use YYYY-MM-DD format. Leave empty to include all dates returned by Remote OK."
                    },
                    "salaryOnly": {
                        "title": "Salary only",
                        "type": "boolean",
                        "description": "If enabled, save only jobs with a non-zero salary range.",
                        "default": false
                    },
                    "includeDescriptionHtml": {
                        "title": "Include HTML descriptions",
                        "type": "boolean",
                        "description": "Include Remote OK's original HTML job description in addition to cleaned text. This makes records larger but preserves formatting.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
