# Workopolis Jobs Scraper (`solidcode/workopolis-scraper`) Actor
\[💰 $0.95 / 1K] Extract job listings from Workopolis. Search by keyword and location, filter by date posted, employment type, and work setting, and get titles, companies, salaries, descriptions, and direct apply links.
- **URL**: https://apify.com/solidcode/workopolis-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, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.95 / 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
## Workopolis Jobs Scraper
Pull job postings from Workopolis at scale — titles, employers, salaries, full descriptions, employment types, work settings, posted dates, and direct apply links for every job across Canada. Search by keyword and city, or paste a Workopolis search URL and scrape it exactly as you set it up on the site. Built for recruiters, job-market researchers, and job-search platforms who need fresh Canadian hiring data without copying postings one page at a time.
### Why This Scraper?
- **Every job across Canada, province or city level** — search "Toronto", "Vancouver", or a whole province like "Ontario", or leave the location empty to sweep the entire country.
- **Up to 2,000 jobs per keyword, many keywords per run** — run 50 keywords in a single invocation; results merge into one dataset and de-duplicate by job ID so the same posting never lands twice.
- **9 employment-type filters** — Full-time, Part-time, Permanent, Contract, Fixed-term, Temporary, Internship/Co-op, Casual, and Freelance.
- **3 work-setting filters** — On-site, Remote, or Hybrid, so you can isolate exactly the kind of role you track.
- **5 date-posted windows** — Any time, last 24 hours, last 7 days, last 14 days, or last 30 days to catch only the freshest openings.
- **Structured salary, not just free text** — minimum, maximum, currency, and pay period pulled from each posting and formatted into a clean salary range.
- **Full job descriptions in plain text, HTML, or both** — choose the format per run, with listed benefits captured alongside the description.
- **Direct apply links on every row** — each job carries its canonical apply URL, so recruiters and candidates go straight to the source.
- **One-click full-detail enrichment** — turn on Fetch Full Job Details to pull the complete description, structured salary, work setting, and benefits from each job's own page.
### Use Cases
**Recruitment & Sourcing**
- Build candidate-facing job feeds for a niche, city, or province
- Track which employers are hiring for a given role across Canada
- Monitor brand-new postings every day with the 24-hour date filter
- Surface direct apply links for fast outreach to active openings
**Job-Market Research**
- Measure hiring demand for a skill or title across Canadian cities
- Compare full-time vs. contract vs. freelance mix in a sector
- Track remote, hybrid, and on-site availability over time
- Map employment trends by province for labour-market reports
**Salary Benchmarking**
- Collect posted salary ranges by title, city, and employment type
- Build compensation bands from minimum/maximum salary fields
- Benchmark pay for the same role across regions
- Track salary movement for a role over weeks of fresh postings
**Job Aggregators & Platforms**
- Power a Canadian job board with continuously refreshed listings
- Feed structured postings into a job-matching or alerting product
- Enrich an existing listings database with descriptions and benefits
- Keep apply links current as postings rotate
**Lead Generation**
- Identify companies actively expanding in a market
- Build employer contact lists from companies posting roles
- Spot hiring surges that signal growth or new funding
### Getting Started
#### Quick Keyword Search
The simplest run — one keyword in one city:
```json
{
"searchQueries": ["software engineer"],
"location": "Toronto",
"maxResults": 50
}
````
#### Filtered Search
Recent, remote, full-time roles only:
```json
{
"searchQueries": ["registered nurse", "nurse practitioner"],
"location": "Ontario",
"datePosted": "7",
"employmentType": "fulltime",
"workSetting": "remote",
"maxResults": 200
}
```
#### Advanced — Direct URLs + Full Detail
Paste search URLs dialed in on the Workopolis site and pull the full detail for every job:
```json
{
"startUrls": [
"https://www.workopolis.com/search?q=data+analyst&l=Vancouver%2C+BC"
],
"searchQueries": ["data analyst"],
"location": "Vancouver",
"datePosted": "14",
"maxResults": 500,
"includeJobDetails": true,
"descriptionFormat": "both"
}
```
### Input Reference
#### What to Search
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["software engineer"]` | Job titles or keywords to search. Each keyword runs its own search; results merge and de-duplicate. Up to 50 keywords per run. Leave empty to use only the direct URLs below. |
| `location` | string | `"Toronto"` | City or region within Canada (e.g. "Toronto", "Vancouver", "Ontario"). Leave empty to search all of Canada. |
| `startUrls` | string\[] | `[]` | Paste full Workopolis search-result URLs to scrape them exactly as-is. Any filters baked into the URL are honored and pagination is automatic. Up to 50 URLs per run. |
#### Filters & Limits
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `datePosted` | select | `Any time` | Only show jobs posted within Any time, Last 24 hours, Last 7 days, Last 14 days, or Last 30 days. |
| `employmentType` | select | `Any` | Filter by type: Full-time, Part-time, Permanent, Contract, Fixed term contract, Temporary, Internship / Co-op, Casual, or Freelance. |
| `workSetting` | select | `Any` | Filter by where the work happens: On-site, Remote, or Hybrid. |
| `maxResults` | integer | `100` | Maximum jobs per keyword (1–2,000). The last page is kept in full, so the final count can slightly overshoot. |
#### Advanced
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeJobDetails` | boolean | `true` | Fetch the full description, structured salary, work setting, and benefits from each job's detail page. Turn off for faster, lighter scans. |
| `descriptionFormat` | select | `Plain text` | How to return the description: Plain text, HTML (keeps formatting), or Both in their own fields. |
### Output
Each job is one flat row. Here's a representative result with full details enabled:
```json
{
"title": "Senior Software Engineer",
"company": "Maple Tech Inc.",
"location": "Toronto, ON",
"salary": "$110,000 - $140,000 a year",
"employmentType": "Full-time",
"workSetting": "Hybrid",
"postedDate": "2026-06-12",
"snippet": "We are looking for a senior engineer to join our platform team...",
"description": "About the role\nWe are looking for a senior engineer to join our platform team. You will design and ship backend services...",
"descriptionHtml": "About the role
We are looking for a senior engineer...
",
"benefits": "Dental care, Extended health care, RRSP match, Paid time off",
"jobUrl": "https://www.workopolis.com/jobsearch/viewjob/abc123def456",
"jobId": "abc123def456",
"searchQuery": "software engineer",
"searchLocation": "Toronto, ON",
"scrapedAt": "2026-06-20T14:30:00Z"
}
```
#### Core Fields
| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Job title |
| `company` | string | Hiring company or employer name |
| `location` | string | Job location (city, province) |
| `jobUrl` | string | Canonical job/apply URL |
| `jobId` | string | Unique job identifier (used for de-duplication) |
| `postedDate` | string | Date the job was posted (ISO format) |
#### Compensation & Role
| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | Salary range as posted (range, currency, and pay period; null if not stated) |
| `employmentType` | string | Full-time, Part-time, Contract, etc. |
| `workSetting` | string | On-site, Remote, or Hybrid, when stated |
| `benefits` | string | Listed benefits and perks (when published) |
#### Description & Metadata
| Field | Type | Description |
|-------|------|-------------|
| `snippet` | string | Short search-result preview text |
| `description` | string | Full plain-text description (when `descriptionFormat` includes text) |
| `descriptionHtml` | string | Full HTML description (when `descriptionFormat` includes html) |
| `searchQuery` | string | The keyword that produced this row |
| `searchLocation` | string | The location used for the search |
| `scrapedAt` | string | ISO timestamp of extraction |
### Tips for Best Results
- **Mirror an exact on-site search with a URL** — set up the search you want on the Workopolis website, copy the address bar into `startUrls`, and the run reproduces it filter-for-filter, including any options not exposed as inputs here.
- **Keep Fetch Full Job Details on for the richest data** — it's the only way to get the complete description, structured salary, work setting, and benefits. Turn it off only when you need a fast, lightweight scan and the snippet is enough.
- **Remote is the most efficient work-setting filter** — Remote roles are isolated directly at search time, while On-site and Hybrid are matched as each job is read, so very specific On-site/Hybrid combinations may take a little longer to fill on markets where few jobs match.
- **Run several keywords at once** — list every title you track in `searchQueries`; they share one run and de-duplicate automatically, so a posting found by two keywords appears only once.
- **Start small, then scale** — try `maxResults` of 25–50 to confirm the data fits your needs, then raise it up to 2,000 per keyword for deep coverage.
- **Pick the description format you'll actually use** — choose Plain text for clean analysis, HTML to preserve formatting, or Both to keep every option open.
- **Use the 24-hour window for daily monitoring** — schedule a run with `datePosted` set to Last 24 hours to capture only brand-new postings each day.
### Pricing
**From $0.95 per 1,000 results** — the lowest-cost way to collect Canadian job listings at scale. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows the total cost at each discount tier.
| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.11 | $0.10 | $0.10 |
| 1,000 | $1.10 | $1.05 | $1.00 | $0.95 |
| 10,000 | $11.00 | $10.50 | $10.00 | $9.50 |
| 100,000 | $110.00 | $105.00 | $100.00 | $95.00 |
A "result" is any job row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.
### 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 results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access
### Legal & Ethical Use
This actor is designed for legitimate recruitment research, labour-market analysis, and job-feed aggregation. Users are responsible for complying with applicable laws and Workopolis's terms of service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data in line with applicable privacy regulations.
# Actor input Schema
## `searchQueries` (type: `array`):
Job titles or keywords to search for, such as 'software engineer' or 'registered nurse'. Each keyword runs a separate search and the results are merged and de-duplicated. Up to 50 keywords per run. Leave empty if you only want to use the direct search URLs below.
## `location` (type: `string`):
Where to search within Canada. Enter a city or region, such as 'Toronto', 'Vancouver', or 'Ontario'. Leave empty to search all of Canada.
## `startUrls` (type: `array`):
Paste full Workopolis search-result URLs to scrape them exactly as-is. Any filters baked into a search URL are honored, and pagination is handled automatically. Useful when you have already dialed in a search on the Workopolis website. Up to 50 URLs per run.
## `datePosted` (type: `string`):
Only show jobs posted within this time period.
## `employmentType` (type: `string`):
Filter by the type of employment. Leave on 'Any' for all types.
## `workSetting` (type: `string`):
Filter by where the work happens. Leave on 'Any' for all options. On-site and Hybrid are matched while reading each job, so very specific combinations may take a little longer to fill on markets where few jobs match.
## `maxResults` (type: `integer`):
Maximum number of jobs to collect for each search keyword. Use a small number for a quick scan or a higher number for deep research. The last page is always kept in full, so the final count can slightly overshoot this number.
## `includeJobDetails` (type: `boolean`):
Fetch the full description, salary, and other details from each job's detail page. Leave on for the richest data. Turn off for faster, lighter scans — the description and salary fields will then be empty or limited to the search-result snippet.
## `descriptionFormat` (type: `string`):
How to return the job description. 'Text' gives clean plain text, 'HTML' preserves formatting, 'Both' includes each in its own field.
## Actor input object example
```json
{
"searchQueries": [
"software engineer"
],
"location": "Toronto",
"startUrls": [],
"datePosted": "",
"employmentType": "",
"workSetting": "",
"maxResults": 100,
"includeJobDetails": true,
"descriptionFormat": "text"
}
```
# Actor output Schema
## `overview` (type: `string`):
Table of scraped job listings with key fields.
## `detail` (type: `string`):
Complete job data including full descriptions, salary, work setting, and search context.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"searchQueries": [
"software engineer"
],
"location": "Toronto",
"startUrls": [],
"datePosted": "",
"employmentType": "",
"workSetting": "",
"maxResults": 100,
"includeJobDetails": true,
"descriptionFormat": "text"
};
// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/workopolis-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"searchQueries": ["software engineer"],
"location": "Toronto",
"startUrls": [],
"datePosted": "",
"employmentType": "",
"workSetting": "",
"maxResults": 100,
"includeJobDetails": True,
"descriptionFormat": "text",
}
# Run the Actor and wait for it to finish
run = client.actor("solidcode/workopolis-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 '{
"searchQueries": [
"software engineer"
],
"location": "Toronto",
"startUrls": [],
"datePosted": "",
"employmentType": "",
"workSetting": "",
"maxResults": 100,
"includeJobDetails": true,
"descriptionFormat": "text"
}' |
apify call solidcode/workopolis-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=solidcode/workopolis-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Workopolis Jobs Scraper",
"description": "[💰 $0.95 / 1K] Extract job listings from Workopolis. Search by keyword and location, filter by date posted, employment type, and work setting, and get titles, companies, salaries, descriptions, and direct apply links.",
"version": "1.0",
"x-build-id": "QqgtoLIIf1NaQnpK8"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/solidcode~workopolis-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-solidcode-workopolis-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~workopolis-scraper/runs": {
"post": {
"operationId": "runs-sync-solidcode-workopolis-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~workopolis-scraper/run-sync": {
"post": {
"operationId": "run-sync-solidcode-workopolis-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": {
"searchQueries": {
"title": "Search Keywords",
"maxItems": 50,
"type": "array",
"description": "Job titles or keywords to search for, such as 'software engineer' or 'registered nurse'. Each keyword runs a separate search and the results are merged and de-duplicated. Up to 50 keywords per run. Leave empty if you only want to use the direct search URLs below.",
"items": {
"type": "string"
}
},
"location": {
"title": "Location",
"type": "string",
"description": "Where to search within Canada. Enter a city or region, such as 'Toronto', 'Vancouver', or 'Ontario'. Leave empty to search all of Canada."
},
"startUrls": {
"title": "Direct Workopolis Search URLs",
"maxItems": 50,
"type": "array",
"description": "Paste full Workopolis search-result URLs to scrape them exactly as-is. Any filters baked into a search URL are honored, and pagination is handled automatically. Useful when you have already dialed in a search on the Workopolis website. Up to 50 URLs per run.",
"items": {
"type": "string"
}
},
"datePosted": {
"title": "Posted Within",
"enum": [
"",
"1",
"7",
"14",
"30"
],
"type": "string",
"description": "Only show jobs posted within this time period.",
"default": ""
},
"employmentType": {
"title": "Employment Type",
"enum": [
"",
"fulltime",
"parttime",
"permanent",
"contract",
"fixedterm",
"temporary",
"internship",
"casual",
"freelance"
],
"type": "string",
"description": "Filter by the type of employment. Leave on 'Any' for all types.",
"default": ""
},
"workSetting": {
"title": "Work Setting",
"enum": [
"",
"onsite",
"remote",
"hybrid"
],
"type": "string",
"description": "Filter by where the work happens. Leave on 'Any' for all options. On-site and Hybrid are matched while reading each job, so very specific combinations may take a little longer to fill on markets where few jobs match.",
"default": ""
},
"maxResults": {
"title": "Max Results per Search",
"minimum": 1,
"maximum": 2000,
"type": "integer",
"description": "Maximum number of jobs to collect for each search keyword. Use a small number for a quick scan or a higher number for deep research. The last page is always kept in full, so the final count can slightly overshoot this number.",
"default": 100
},
"includeJobDetails": {
"title": "Fetch Full Job Details",
"type": "boolean",
"description": "Fetch the full description, salary, and other details from each job's detail page. Leave on for the richest data. Turn off for faster, lighter scans — the description and salary fields will then be empty or limited to the search-result snippet.",
"default": true
},
"descriptionFormat": {
"title": "Description Format",
"enum": [
"text",
"html",
"both"
],
"type": "string",
"description": "How to return the job description. 'Text' gives clean plain text, 'HTML' preserves formatting, 'Both' includes each in its own field.",
"default": "text"
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```