# We Work Remotely Jobs Scraper (`parseforge/we-work-remotely-scraper`) Actor

Scrape remote job listings from We Work Remotely. Export title, company, category, location, job type, tags, and more to CSV, Excel, JSON, or XML.

- **URL**: https://apify.com/parseforge/we-work-remotely-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💼 We Work Remotely Jobs Scraper

> 🚀 **Export remote job listings from We Work Remotely in seconds.** Scrape job title, company, category, location, job type, skills tags, and more - no account required.

> 🕒 **Last updated:** 2026-05-21 · **📊 10 fields** per record · **400+ active jobs** · **10 categories** · **🌍 Global remote roles**

The **We Work Remotely Scraper** exports live job listings from [weworkremotely.com](https://weworkremotely.com) - one of the largest and most established remote job boards on the internet. It returns **10 fields per record**, including job title, company name, category, location, job type, skills tags, and the direct application URL.

The platform hosts remote positions across 10 job categories, from software engineering and design to customer support and marketing. This Actor fetches that data in real-time and delivers it as CSV, Excel, JSON, or XML in under 60 seconds. No browser automation, no login, no scraping complexity.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Recruiters, HR teams, job aggregators, career coaches, workforce researchers, developers | Remote job market analysis, job board aggregation, talent pipeline sourcing, skills trend monitoring, salary benchmarking |

---

### 📋 What the We Work Remotely Scraper does

Four workflows in a single run:

- 🌍 **Full board export.** All active remote jobs across every category.
- 🗂️ **Category filter.** Target one specific category - Back-End Programming, Design, Customer Support, Sales and Marketing, and more.
- 📊 **Skills intelligence.** Every job includes a `tags` array of required skills for trend analysis.
- 🔗 **Direct links.** Each record includes the canonical job URL for immediate application or archiving.

Each record includes company logo URL, job title, company name, category, application URL, location requirement, job type (full-time/contract), skills tags, and posted date.

> 💡 **Why it matters:** remote job market intelligence requires consistent, structured data. Building your own RSS parser, deduplicating across 10 category feeds, and normalizing fields takes hours. This Actor delivers clean, deduplicated, typed data on every run - ready for your spreadsheet, database, or dashboard.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>category</code></td><td>string</td><td><code>""</code></td><td>Category slug to filter by. Empty = all categories.</td></tr>
</tbody>
</table>

**All categories available:**

| Slug | Label |
|---|---|
| _(empty)_ | All Categories |
| `remote-back-end-programming-jobs` | Back-End Programming |
| `remote-front-end-programming-jobs` | Front-End Programming |
| `remote-full-stack-programming-jobs` | Full-Stack Programming |
| `remote-design-jobs` | Design |
| `remote-devops-sysadmin-jobs` | DevOps and Sysadmin |
| `remote-product-jobs` | Product |
| `remote-customer-support-jobs` | Customer Support |
| `remote-management-and-finance-jobs` | Management and Finance |
| `remote-sales-and-marketing-jobs` | Sales and Marketing |
| `all-other-remote-jobs` | All Other Remote |

**Example 1 - All remote jobs (default preview):**
```json
{
  "maxItems": 10
}
````

**Example 2 - Engineering jobs only:**

```json
{
  "maxItems": 100,
  "category": "remote-full-stack-programming-jobs"
}
```

> ⚠️ **Good to Know:** The We Work Remotely RSS feed is updated in real-time and typically contains 10-126 active listings per category. Running without a `category` filter sweeps all 10 categories and returns up to `maxItems` total results.

***

### 📊 Output

Each record contains **10 fields**:

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string / null | Company logo URL (conditionally present) |
| 📝 `title` | string | Job title |
| 🏢 `company` | string | Company name |
| 🗂️ `category` | string | Job category (e.g. "Back-End Programming") |
| 🔗 `url` | string | Direct URL to the job listing |
| 📍 `location` | string | Location requirement (e.g. "Anywhere in the World") |
| 💼 `jobType` | string / null | Employment type (e.g. "Full-Time", "Contract") |
| 🏷️ `tags` | array | Required skills (e.g. \["Ruby on Rails", "Python"]) |
| 📅 `postedAt` | string | ISO 8601 date the job was posted |
| 🕒 `scrapedAt` | string | ISO 8601 date this record was scraped |

**Sample records (real output):**

```json
[
  {
    "imageUrl": "https://wwr-pro.s3.amazonaws.com/logos/0171/2344/logo.gif",
    "title": "Senior Ruby on Rails Developer",
    "company": "OnTheGoSystems",
    "category": "Back-End Programming",
    "url": "https://weworkremotely.com/remote-jobs/onthegosystems-senior-ruby-on-rails-developer-2",
    "location": "Anywhere in the World",
    "jobType": "Full-Time",
    "tags": ["Ruby on Rails and Artificial Intelligence (AI)"],
    "postedAt": "2026-05-19T06:26:21.000Z",
    "scrapedAt": "2026-05-21T22:53:23.514Z"
  },
  {
    "imageUrl": null,
    "title": "Blockchain Engineer & Researcher",
    "company": "FairGambling",
    "category": "Back-End Programming",
    "url": "https://weworkremotely.com/remote-jobs/fairgambling-blockchain-engineer-researcher",
    "location": "Anywhere in the World",
    "jobType": "Full-Time",
    "tags": [],
    "postedAt": "2026-05-18T12:15:53.000Z",
    "scrapedAt": "2026-05-21T22:53:23.514Z"
  },
  {
    "imageUrl": "https://wwr-pro.s3.amazonaws.com/logos/0171/5141/logo.gif",
    "title": "Staff Software Engineer (Magic Containers)",
    "company": "bunny.net",
    "category": "Back-End Programming",
    "url": "https://weworkremotely.com/remote-jobs/bunny-net-staff-software-engineer-magic-containers",
    "location": "Anywhere in the World",
    "jobType": "Full-Time",
    "tags": ["Containers", "Linux", "Network Protocols", "C#", "Kubernetes", "and Large-scale Distributed Systems"],
    "postedAt": "2026-05-12T12:34:46.000Z",
    "scrapedAt": "2026-05-21T22:53:23.515Z"
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🚀 **Real-time data** | Fetches live listings directly from the We Work Remotely RSS feed |
| 🗂️ **10 categories covered** | One run covers the entire board or a single focused category |
| 🏷️ **Skills tags parsed** | Comma-separated skills string split into a clean array |
| 🖼️ **Company logos included** | Image URLs ready to embed in your UI or dashboard |
| 📥 **4 export formats** | Download as CSV, Excel, JSON, or XML with one click |
| ⚡ **Fast** | Typical run completes in under 10 seconds for 100 items |
| 🌐 **No login required** | No account, no API key, no browser headaches |

***

### 📈 How it compares to alternatives

| Approach | Setup Time | Data Freshness | Fields | Cost |
|---|---|---|---|---|
| **This Actor** | 2 minutes | Real-time | 10 structured fields | Pay-per-result |
| Manual RSS parsing | Hours of code | Real-time | Requires custom parser | Dev time |
| Copy-paste from site | Manual | Snapshot | No structure | Time-consuming |
| Third-party job APIs | Days of integration | Often delayed | Variable | Subscription |

***

### 🚀 How to use

1. **[Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp)** - get $5 free credit, no credit card required.
2. Open the **We Work Remotely Scraper** on Apify.
3. Set `maxItems` to how many jobs you want (default: 10).
4. Optionally select a `category` to narrow results.
5. Click **Start** and download your dataset as CSV, Excel, JSON, or XML.

***

### 💼 Business use cases

#### 🔍 Talent sourcing and recruitment

Build a pipeline of companies actively hiring for remote roles. Track hiring trends by category, identify companies that post frequently, and get direct application links for your candidates.

#### 📊 Remote job market research

Analyze which skills are most in demand, how job type distributions shift over time, and which categories are growing. Export to Excel for your next workforce report.

#### 🤝 Job board aggregation

Power your own job board with live We Work Remotely listings. Combine this Actor with others (LinkedIn, Greenhouse, Lever) to build a comprehensive remote-only job aggregator.

#### 🎯 Competitive intelligence

Monitor which companies are expanding their remote teams, what roles they are hiring for, and how that changes month over month - without manually checking the site every day.

***

### 🔌 Automating We Work Remotely Scraper

Connect this Actor to your favorite automation tools without writing code:

- **Make (Integromat)** - Schedule daily runs and push new jobs to Google Sheets, Airtable, or a Slack channel automatically.
- **Zapier** - Trigger on new dataset items and send alerts to your CRM, email list, or Notion database.
- **Slack** - Post a daily digest of new remote engineering or design jobs to your team channel.
- **Airbyte** - Sync the dataset to your data warehouse (BigQuery, Snowflake, Redshift) for long-term trend analysis.

All integrations are available from the **Integrations** tab on the Actor page.

***

### 🌟 Beyond business use cases

#### 🎓 Academic research

Study the evolution of remote work, skill demand shifts post-pandemic, or geographic distribution of location requirements in distributed teams.

#### 🌱 Non-profit and social good

Help career coaches at non-profits feed structured remote job data to their clients. Many underserved communities benefit most from remote-first opportunities.

#### 🛠️ Developer experimentation

Use the clean, predictable JSON output as a test dataset for NLP pipelines, job recommendation systems, or machine learning experiments on job descriptions.

#### 📰 Journalism and newsletters

Power a weekly newsletter or blog post with the latest remote opportunities. Automate the data collection so you focus on the editorial angle.

***

### 🤖 Ask an AI assistant about this scraper

Not sure if this Actor fits your use case? Open your AI assistant and ask:

> "I want to scrape remote job listings from We Work Remotely, including job title, company, category, skills, and application URL. I found a ParseForge actor that fetches the RSS feed across 10 categories. Can you help me set up a daily run that saves results to a Google Sheet?"

The structured output makes this Actor ideal for AI-assisted pipelines.

***

### ❓ Frequently Asked Questions

**❓ How many jobs does the scraper return?**
The main RSS feed provides up to 100 jobs (10 per category). Category-specific feeds return 10-126 jobs. Use `maxItems` to cap the output.

**❓ How often is the data updated?**
We Work Remotely updates their RSS feed continuously as new jobs are posted. Each Actor run fetches the latest available listings.

**❓ Do I need a We Work Remotely account?**
No. The RSS feed is publicly accessible without authentication.

**❓ Why is `imageUrl` null for some jobs?**
Company logos are optional on We Work Remotely. Not all employers upload one. When absent, the field returns `null`.

**❓ Why is `jobType` null for some jobs?**
Job type is an optional field in the source. When not specified by the employer, it returns `null`.

**❓ Can I scrape a specific category only?**
Yes. Set the `category` input to any of the 10 supported slugs (e.g. `remote-full-stack-programming-jobs`).

**❓ What does `tags` contain?**
The `tags` array contains skills and technologies required for the job, as listed by the employer (e.g. `["Python", "Django", "PostgreSQL"]`).

**❓ How fast does the Actor run?**
A typical run for 100 items completes in under 15 seconds. For 10 items, usually under 5 seconds.

**❓ Can I run this on a schedule?**
Yes. Use the Apify Scheduler to run the Actor daily, weekly, or on any cron schedule. Combine with an integration to push results to your preferred destination automatically.

**❓ Is the scraper affected by Cloudflare or anti-bot protection?**
No. The Actor reads the public RSS feed which is not protected by Cloudflare or any bot detection.

**❓ Can I scrape job detail pages for full descriptions?**
This Actor scrapes the listing metadata available in the RSS feed. Full job descriptions are not included in the current version.

**❓ What export formats are supported?**
CSV, Excel (.xlsx), JSON, and XML - available from the Apify dataset download UI with one click.

***

### 🔌 Integrate with any app

Download your dataset as **CSV, Excel, JSON, or XML** from the Apify Console. Or connect directly via the Apify API:

```
GET https://api.apify.com/v2/datasets/{datasetId}/items?format=csv&token={yourToken}
```

Supported integrations include: Google Sheets, Airtable, Notion, Zapier, Make, n8n, Slack, Discord, HubSpot, Salesforce, BigQuery, Snowflake, Redshift, MongoDB, PostgreSQL, and any REST endpoint.

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [ParseForge LinkedIn Jobs Scraper](https://apify.com/parseforge) | Scrape LinkedIn job postings with full detail |
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database - 85,000+ airports |
| [ParseForge CVS Reviews Scraper](https://apify.com/parseforge) | Customer reviews and ratings from CVS |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more high-quality, no-maintenance scrapers across jobs, travel, retail, and finance.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by We Work Remotely. It reads publicly available RSS feeds in accordance with standard web access practices. Use responsibly and in compliance with We Work Remotely's terms of service.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `category` (type: `string`):

Filter jobs by category. Leave empty to scrape all categories.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/we-work-remotely-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/we-work-remotely-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 '{
  "maxItems": 10
}' |
apify call parseforge/we-work-remotely-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/we-work-remotely-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. Export title, company, category, location, job type, tags, and more to CSV, Excel, JSON, or XML.",
        "version": "0.1",
        "x-build-id": "7N5ANjG3in7RFQr7a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~we-work-remotely-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-we-work-remotely-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/parseforge~we-work-remotely-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-we-work-remotely-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/parseforge~we-work-remotely-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-we-work-remotely-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "remote-back-end-programming-jobs",
                            "remote-front-end-programming-jobs",
                            "remote-full-stack-programming-jobs",
                            "remote-design-jobs",
                            "remote-devops-sysadmin-jobs",
                            "remote-product-jobs",
                            "remote-customer-support-jobs",
                            "remote-management-and-finance-jobs",
                            "remote-sales-and-marketing-jobs",
                            "all-other-remote-jobs"
                        ],
                        "type": "string",
                        "description": "Filter jobs by category. Leave empty to scrape all categories."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
