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

\[💰 $1.0 / 1K] Extract remote job listings from We Work Remotely. Filter by keyword, category, region, employment type, and recency. Get titles, companies, salaries, descriptions, and apply links.

- **URL**: https://apify.com/solidcode/weworkremotely-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (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 $1.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## We Work Remotely Jobs Scraper

Extract every remote job posted on We Work Remotely — title, company, region, salary, employment type, posting date, full description, and apply link — in one structured dataset. Built for recruiters sourcing remote candidates, job-board aggregators, salary-data analysts, and ATS integrations that need fresh remote-job data without crawling listing pages by hand.

### Why This Scraper?

- **All 11 official We Work Remotely categories** — Full-Stack, Front-End, Back-End, Software Developer, Design, DevOps & Sysadmin, Management & Finance, Product, Customer Support, Sales & Marketing, and All Other Remote Jobs, each selectable from a dropdown.
- **5 region presets that respect "Anywhere in the World"** — Anywhere, USA Only, Americas, EMEA, and APAC. Each preset is applied first against the listing card badge, then re-checked against the JSON-LD `applicantLocationRequirements` on the detail page so worldwide-eligible jobs are never silently dropped from a US-only run.
- **Parsed salary into `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryInterval`** — pulled from the JobPosting structured data, with the raw human-readable string preserved as `salaryRaw`. Compensation is spreadsheet-ready, not a free-text blob.
- **3 employment-type options + 5 "posted within" windows** — Full-Time or Contract; 24 hours, 3 days, 7 days, 30 days, or Any time. Filters apply both pre-fetch (cheap card scan) and post-fetch (authoritative JSON-LD).
- **`includeDescription` toggle for cheap light-mode scans** — turn full descriptions off to skim hundreds of jobs at a fraction of the cost, or leave it on for the full `descriptionText`, `descriptionHtml`, parsed salary, and `companyWebsite`.
- **Keyword search across title, company, and description** — uses the native We Work Remotely search and falls back to a category sweep for the Software Developer slug (which the site's own search dropdown silently excludes).
- **`startUrls` accepts any We Work Remotely category or search URL** — paste a saved filter URL directly and bypass the form entirely.
- **Cross-category deduplication** — a job tagged Full-Stack *and* Front-End appears exactly once, deduped on the canonical detail URL.
- **Skill and country tags surfaced as a `categories` array** — every chip on the listing card (AngularJS, PHP, Top 100, country names) is captured alongside the primary category.

### Use Cases

**Recruitment & Talent Sourcing**
- Build a daily feed of new remote Senior Engineer roles in a target stack
- Surface contract-only postings for a freelance bench
- Track competing remote employers hiring for the same role
- Identify worldwide-eligible jobs to widen your candidate funnel

**Market & Salary Research**
- Benchmark remote salaries by category and region with parsed `salaryMin`/`salaryMax`
- Track the share of Full-Time vs. Contract roles over time
- Measure hiring velocity by counting `postedWithin=24h` snapshots day over day
- Compare which categories pay annually vs. hourly using `salaryInterval`

**Job Board & Aggregator Operations**
- Power a niche remote-jobs vertical with a clean, deduped feed
- Cross-post curated remote roles into a Slack or Discord community
- Auto-update a static jobs site from a scheduled We Work Remotely pull
- Run keyword digests (e.g. "rust", "Postgres", "Figma") on a daily schedule

**ATS & CRM Enrichment**
- Enrich a CRM of remote-friendly companies with their currently open roles
- Feed company logos and websites into a partner database
- Stream new postings into Zapier for inbox or Slack alerts
- Match candidate profiles against fresh JobPosting structured data

### Getting Started

#### Minimal — one category, default cap

```json
{
    "categories": ["remote-full-stack-programming-jobs"],
    "maxResults": 25
}
````

#### Keyword + region filter

```json
{
    "searchQuery": "rust",
    "region": "usa",
    "maxResults": 50
}
```

#### Multi-category, last 7 days

```json
{
    "categories": [
        "remote-full-stack-programming-jobs",
        "remote-customer-support-jobs"
    ],
    "postedWithin": "7",
    "maxResults": 100
}
```

#### Direct URL, light mode (no descriptions)

```json
{
    "startUrls": [
        "https://weworkremotely.com/categories/remote-customer-support-jobs"
    ],
    "includeDescription": false,
    "maxResults": 30
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `""` | Free-text keyword such as 'python', 'designer', or 'marketing manager'. Matches against job title, company, and description. Leave empty for no keyword filter. |
| `categories` | string\[] | `[]` | Pick one or more job categories. Leave empty to include all categories. Options: Full-Stack Programming, Front-End Programming, Back-End Programming, Software Developer (general), Design, DevOps & Sysadmin, Management & Finance, Product, Customer Support, Sales & Marketing, All Other Remote Jobs. |
| `region` | select | `Any region` | Geographic eligibility filter. We Work Remotely tags each listing with a region. Options: Any region, Anywhere in the World, USA Only, Americas Only, EMEA Only, APAC Only. |
| `employmentType` | select | `Any` | Filter by employment type. Options: Any, Full-Time, Contract. |
| `postedWithin` | select | `Any time` | Only show jobs posted within this time window. Options: Any time, Last 24 hours, Last 3 days, Last 7 days, Last 30 days. |
| `startUrls` | string\[] | `[]` | Optional. Paste full We Work Remotely search or category URLs (e.g., `https://weworkremotely.com/categories/remote-design-jobs`) to use them directly. When provided, the keyword, categories, region, and employment-type fields above are ignored. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of jobs to collect across all categories/URLs in this run. Set to 0 for no cap. |
| `includeDescription` | boolean | `true` | Fetch the full description, parsed salary, apply URL, and company website from each listing's detail page. Disable for faster light scans — descriptionHtml, descriptionText, applyUrl, salary fields, and companyWebsite will be left null. |

### Output

Each result is a flat one-row-per-job record. Here is a representative row with `includeDescription: true`:

```json
{
    "url": "https://weworkremotely.com/remote-jobs/lemon-io-senior-full-stack-angular-php-developer",
    "guid": "lemon-io-senior-full-stack-angular-php-developer",
    "title": "Senior Full-stack Angular & PHP Developer",
    "company": "Lemon.io",
    "companyWebsite": "https://lemon.io",
    "category": "remote-full-stack-programming-jobs",
    "categories": ["Top 100", "Albania", "Bosnia and Herzegovina", "Full-Stack Programming", "AngularJS", "PHP", "Laravel", "TypeScript"],
    "region": "Argentina",
    "location": "New York, NY",
    "employmentType": "Full-Time",
    "salaryRaw": "$100,000 or more USD",
    "salaryMin": null,
    "salaryMax": null,
    "salaryCurrency": "USD",
    "salaryInterval": "year",
    "datePosted": "2026-05-15T07:36:54+00:00",
    "descriptionText": "Are you a talented Senior Developer looking for a remote job...",
    "applyUrl": null,
    "companyLogo": "https://we-work-remotely.imgix.net/logos/lemon-io.png",
    "scrapedAt": "2026-05-16T01:13:19.262591+00:00"
}
```

#### Core Job Info

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Canonical We Work Remotely job detail URL |
| `guid` | string | Stable slug used as a unique identifier across runs |
| `title` | string | Job title |
| `company` | string | Hiring company name |
| `category` | string | Primary category slug the job was discovered under |
| `categories` | string\[] | All tags surfaced on the listing card and detail page (skills, countries, badges) |
| `region` | string | Exact region badge from the listing — granular country names ("Argentina", "United States of America") or worldwide-eligibility labels ("Anywhere in the World", "USA only"). Note the asymmetry with the `region` input filter, which has 5 coarse presets — filtering by `usa` still surfaces rows whose `region` reads "United States of America" (specific) or "Anywhere in the World" (worldwide-eligible). Both are legitimately US-eligible. |
| `location` | string | Free-text company headquarters from the listing card |
| `employmentType` | string | Normalized "Full-Time" or "Contract" |
| `datePosted` | string | ISO timestamp of when the job was posted |
| `scrapedAt` | string | ISO timestamp of data extraction |

#### Salary & Compensation

| Field | Type | Description |
|-------|------|-------------|
| `salaryRaw` | string | Human-readable salary string as displayed on the listing (e.g. "$100,000 or more USD") |
| `salaryMin` | number | Parsed minimum salary value |
| `salaryMax` | number | Parsed maximum salary value |
| `salaryCurrency` | string | Three-letter currency code (e.g. "USD", "EUR") |
| `salaryInterval` | string | Pay interval (year, month, week, day, hour) |

#### Company & Description

| Field | Type | Description |
|-------|------|-------------|
| `companyWebsite` | string | Company homepage URL from the JobPosting structured data |
| `companyLogo` | string | Company logo image URL |
| `descriptionText` | string | Plain-text job description |
| `descriptionHtml` | string | Original HTML job description with formatting preserved |
| `applyUrl` | string | Direct apply link (We Work Remotely gates this behind login; usually null — use `companyWebsite` as the substitute) |

### Tips for Best Results

- **Start with `maxResults: 25`** on your first run to confirm the filter combo returns what you expect, then scale up.
- **Use `includeDescription: false` for cheap snapshots** — counts, titles, companies, regions, and card-level salaries come back in a single page hit per category, no detail fetch.
- **For salary research, set one category at `maxResults: 0`** and filter the resulting spreadsheet on `salaryCurrency` — you get a complete cross-section without configuring pagination.
- **To monitor a niche keyword, schedule the actor daily with `postedWithin: "1"`** and `searchQuery` set to your term — each run returns only fresh postings from the last 24 hours.
- **Cross-reference `region: "anywhere"` against `region: "usa"`** to surface roles that are worldwide-eligible but specifically include the US, versus roles that are US-only.
- **Paste a saved filter URL into `startUrls`** to bypass the form — the actor preserves your category and search-term selection exactly as the site interprets them.
- **`applyUrl` is gated behind a We Work Remotely login** and will be null in the output. The `companyWebsite` field is the closest direct-application substitute.

### Pricing

**$1.00 per 1,000 results** — pay only for what you get. No compute charges — you only pay per result returned.

| Results | Cost |
|---------|------|
| 100 | $0.10 |
| 1,000 | $1.00 |
| 10,000 | $10.00 |
| 100,000 | $100.00 |

A "result" is any job row in the output dataset. Platform fees (compute, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new postings
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate recruitment research, market analysis, and job-aggregation use cases. Users are responsible for complying with applicable laws and We Work Remotely's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose. Respect candidate privacy and the hiring company's stated application channels.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword such as 'python', 'designer', or 'marketing manager'. Matches against job title, company, and description. Leave empty for no keyword filter.

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

Pick one or more job categories. Leave empty to include all categories.

## `region` (type: `string`):

Geographic eligibility filter. We Work Remotely tags each listing with a region. Leave on 'Any' for no region filter.

## `employmentType` (type: `string`):

Filter by employment type. Leave on 'Any' for both.

## `postedWithin` (type: `string`):

Only show jobs posted within this time window.

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

Optional. Paste full We Work Remotely search or category URLs (e.g., https://weworkremotely.com/categories/remote-design-jobs) to use them directly. When provided, the keyword, categories, region, and employment-type fields above are ignored.

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

Maximum number of jobs to collect across all categories/URLs in this run. Set to 0 for no cap.

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

Fetch the full description, parsed salary, apply URL, and company website from each listing's detail page. Disable for faster light scans — descriptionHtml, descriptionText, applyUrl, salary fields, and companyWebsite will be left null.

## Actor input object example

```json
{
  "categories": [],
  "region": "",
  "employmentType": "",
  "postedWithin": "",
  "startUrls": [],
  "maxResults": 100,
  "includeDescription": true
}
```

# Actor output Schema

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

Table of jobs with the most useful fields: title, company, category, region, salary, and link.

## `details` (type: `string`):

Full per-job rows including description, salary breakdown, and apply URL.

# 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 = {
    "searchQuery": "",
    "categories": [],
    "region": "",
    "employmentType": "",
    "postedWithin": "",
    "startUrls": [],
    "maxResults": 100,
    "includeDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/weworkremotely-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 = {
    "searchQuery": "",
    "categories": [],
    "region": "",
    "employmentType": "",
    "postedWithin": "",
    "startUrls": [],
    "maxResults": 100,
    "includeDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/weworkremotely-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 '{
  "searchQuery": "",
  "categories": [],
  "region": "",
  "employmentType": "",
  "postedWithin": "",
  "startUrls": [],
  "maxResults": 100,
  "includeDescription": true
}' |
apify call solidcode/weworkremotely-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "We Work Remotely Jobs Scraper",
        "description": "[💰 $1.0 / 1K] Extract remote job listings from We Work Remotely. Filter by keyword, category, region, employment type, and recency. Get titles, companies, salaries, descriptions, and apply links.",
        "version": "1.0",
        "x-build-id": "XbYYDgPFcI6dnvCKb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~weworkremotely-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-weworkremotely-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/solidcode~weworkremotely-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-weworkremotely-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/solidcode~weworkremotely-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-weworkremotely-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": {
                    "searchQuery": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Free-text keyword such as 'python', 'designer', or 'marketing manager'. Matches against job title, company, and description. Leave empty for no keyword filter."
                    },
                    "categories": {
                        "title": "Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Pick one or more job categories. Leave empty to include all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "remote-full-stack-programming-jobs",
                                "remote-front-end-programming-jobs",
                                "remote-back-end-programming-jobs",
                                "remote-software-developer-jobs",
                                "remote-design-jobs",
                                "remote-devops-sysadmin-jobs",
                                "remote-management-and-finance-jobs",
                                "remote-product-jobs",
                                "remote-customer-support-jobs",
                                "remote-sales-and-marketing-jobs",
                                "all-other-remote-jobs"
                            ],
                            "enumTitles": [
                                "Full-Stack Programming",
                                "Front-End Programming",
                                "Back-End Programming",
                                "Software Developer (general)",
                                "Design",
                                "DevOps & Sysadmin",
                                "Management & Finance",
                                "Product",
                                "Customer Support",
                                "Sales & Marketing",
                                "All Other Remote Jobs"
                            ]
                        },
                        "default": []
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "",
                            "anywhere",
                            "usa",
                            "americas",
                            "emea",
                            "apac"
                        ],
                        "type": "string",
                        "description": "Geographic eligibility filter. We Work Remotely tags each listing with a region. Leave on 'Any' for no region filter.",
                        "default": ""
                    },
                    "employmentType": {
                        "title": "Employment Type",
                        "enum": [
                            "",
                            "full_time",
                            "contract"
                        ],
                        "type": "string",
                        "description": "Filter by employment type. Leave on 'Any' for both.",
                        "default": ""
                    },
                    "postedWithin": {
                        "title": "Posted Within",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only show jobs posted within this time window.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Direct We Work Remotely URLs",
                        "type": "array",
                        "description": "Optional. Paste full We Work Remotely search or category URLs (e.g., https://weworkremotely.com/categories/remote-design-jobs) to use them directly. When provided, the keyword, categories, region, and employment-type fields above are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect across all categories/URLs in this run. Set to 0 for no cap.",
                        "default": 100
                    },
                    "includeDescription": {
                        "title": "Include Full Descriptions",
                        "type": "boolean",
                        "description": "Fetch the full description, parsed salary, apply URL, and company website from each listing's detail page. Disable for faster light scans — descriptionHtml, descriptionText, applyUrl, salary fields, and companyWebsite will be left null.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
