# Learn4Good Jobs Scraper (`solidcode/learn4good-scraper`) Actor
\[💰 $10.00 / 1K] Extract job listings from Learn4Good. Search by keyword and location, paste Learn4Good URLs directly, or filter by job type and posting date. Get structured jobs with titles, companies, locations, salaries, types, posting dates, and full descriptions — one clean row per posting.
- **URL**: https://apify.com/solidcode/learn4good-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 $10.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
## Learn4Good Jobs Scraper
Pull job listings from Learn4Good at scale — titles, hiring companies, locations, parsed salaries, employment types, posting dates, expiry dates, and full job descriptions in clean, structured rows. Search across 30 job categories worldwide, filter by employment type and posting date, or paste any Learn4Good URL straight in. Built for recruiters, job-market researchers, and job-board aggregators who need fresh, structured Learn4Good postings without copying listings off the site one page at a time.
### Why This Scraper?
- **30 job categories, worldwide** — nursing, software development, teaching, sales, engineering, hospitality, skilled trades, and more; any keyword you type is matched to the closest Learn4Good category automatically.
- **Six employment-type filters** — Full-time, Part-time, Contract, Internship, Temporary, and Volunteer, applied per run.
- **Four posting-date windows** — last 24 hours, 3 days, 7 days, or 30 days, so you only collect listings that are still fresh.
- **Parsed salary fields, not just text** — every listing returns `salaryMin`, `salaryMax`, and `salaryCurrency` (USD, EUR, GBP, and more) alongside the raw salary string, ready for sorting and analysis.
- **Both plain-text and HTML descriptions** — `descriptionText` for analytics and `descriptionHtml` for rich display, captured from each job's own page.
- **Batch up to 50 keywords per run** — every keyword runs its own search, so a single run can sweep "nurse", "teacher", and "warehouse" at once instead of one keyword per run.
- **Paste any Learn4Good URL directly** — already dialed in a search on the site? Drop the search-result or individual job URL in and every filter baked into that link is preserved.
- **3× faster runs on demand** — flip off full-description fetching when you only need title, company, location, salary, and posting date.
- **Clean cross-page deduplication** — jobs that repeat across result pages are removed by job ID, so every row is unique.
### Use Cases
**Recruiting & Talent Sourcing**
- Build candidate-facing job boards seeded with live Learn4Good roles
- Track open positions by category in your target markets
- Surface fresh postings from the last 24 hours for fast outreach
- Compare role volume across nursing, IT, education, and the trades
**Job-Market Research**
- Measure hiring demand by category, location, and employment type
- Track salary ranges across roles using parsed min/max fields
- Monitor seasonal swings in Temporary and Volunteer postings
- Benchmark posting volume week over week with the posting-date windows
**Job-Board Aggregation**
- Feed a multi-source aggregator with structured Learn4Good listings
- De-duplicate and normalize postings into your own schema
- Keep listings current with scheduled runs and posting-date filters
- Pull full HTML descriptions for rich listing pages
**Lead Generation**
- Identify companies actively hiring in a category or region
- Build outreach lists of hiring organizations from the `company` field
- Spot firms expanding via internships and contract roles
- Target staffing leads by employment type and location
**Data Enrichment & Integration**
- Enrich an existing jobs dataset with Learn4Good salary and date fields
- Power dashboards tracking hiring trends over time
- Feed downstream models plain-text descriptions at scale
- Sync new postings into a CRM or spreadsheet automatically
### Getting Started
#### Search by Keyword
The simplest run — one keyword, everywhere:
```json
{
"searchQueries": ["nurse"]
}
````
#### Keyword + Location + Filters
Narrow to a country, a single employment type, and recent postings only:
```json
{
"searchQueries": ["software developer", "teacher"],
"location": "United States",
"jobType": "full-time",
"postedWithinDays": "7",
"maxResultsPerQuery": 200
}
```
#### Paste Learn4Good URLs Directly
Already have a search dialed in on the site? Scrape those exact pages:
```json
{
"startUrls": [
"https://www.learn4good.com/jobs/language/english/search/nursing/",
"https://www.learn4good.com/jobs/online/usa/nursing/5193000000/e/"
],
"fetchDescription": true,
"maxResultsPerQuery": 100
}
```
### Input Reference
#### What to Scrape
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `["nurse"]` | Job titles, roles, or keywords to search. Each keyword runs its own search and is matched to the closest Learn4Good category. Up to 50 per run. |
| `location` | string | `""` | City, state, or country to search in, such as "California" or "United States". Applies to every keyword. Leave empty to search everywhere. |
| `startUrls` | array | `[]` | Paste full Learn4Good search-result or individual job URLs to scrape them directly. Any filters in the URL are kept. Up to 50 per run. |
#### Filters
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `jobType` | string | `Any` | Only return jobs of one employment type: Full-time, Part-time, Contract, Internship, Temporary, or Volunteer. |
| `postedWithinDays` | string | `Any` | Only return jobs published within a window: last 24 hours, 3 days, 7 days, or 30 days. |
#### Limits & Options
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResultsPerQuery` | integer | `100` | Maximum jobs to collect per keyword or per URL. The whole final page is always kept, so a small cap can return up to a full page more than requested. A single search collects at most about 10,000 jobs as a safety limit, well above any Learn4Good category. |
| `fetchDescription` | boolean | `true` | Fetch each job's full description (plain text and HTML) and extra detail from its own page. Turn off for roughly 3× faster runs; the description fields will be empty. |
### Output
Each job posting becomes one flat row. Example:
```json
{
"jobId": "5193456789",
"title": "Registered Nurse - ICU",
"company": "Springfield General Hospital",
"location": "Boston, Massachusetts, United States",
"salary": "$75,000 - $95,000 per year",
"salaryMin": 75000,
"salaryMax": 95000,
"salaryCurrency": "USD",
"jobType": "full-time, part-time",
"datePosted": "2026-06-20",
"validThrough": "2026-08-19",
"descriptionText": "We are seeking an experienced ICU nurse to join our team...",
"descriptionHtml": "We are seeking an experienced ICU nurse to join our team...
",
"url": "https://www.learn4good.com/jobs/boston/usa/nursing/5193456789/e/",
"searchKeyword": "nurse",
"searchLocation": "United States",
"source": "learn4good.com",
"scrapedAt": "2026-06-26T14:32:08.512000+00:00"
}
```
#### Core Job Fields
| Field | Type | Description |
|-------|------|-------------|
| `jobId` | string | Stable Learn4Good job identifier, used as the cross-page deduplication key. |
| `title` | string | Job position title. |
| `company` | string | Hiring organization. |
| `location` | string | Job location text. |
| `jobType` | string | Employment type(s) for the listing (Full-time, Part-time, Contract, Internship, Temporary, Volunteer). May contain multiple comma-separated types, e.g. `"full-time, part-time"`. |
| `url` | string | Direct link to the job's detail page. |
#### Salary & Dates
| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | Raw salary text as shown on the listing, when present. |
| `salaryMin` | number | Parsed salary floor, when derivable. |
| `salaryMax` | number | Parsed salary ceiling, when derivable. |
| `salaryCurrency` | string | Parsed currency code (USD, EUR, GBP, and more), when derivable. |
| `datePosted` | string | Publication date (ISO format when available). |
| `validThrough` | string | Listing expiry date, when present. |
#### Description & Run Metadata
| Field | Type | Description |
|-------|------|-------------|
| `descriptionText` | string | Plain-text job description (populated when full descriptions are fetched). |
| `descriptionHtml` | string | HTML job description (populated when full descriptions are fetched). |
| `searchKeyword` | string | The keyword that produced this row. |
| `searchLocation` | string | The location filter applied to this run. |
| `source` | string | Source site label ("learn4good.com"). |
| `scrapedAt` | string | ISO timestamp of when the row was collected. |
### Tips for Best Results
- **Keywords map to job categories** — Learn4Good organizes jobs into a fixed set of 30 categories, so a niche term may be matched to a broader one (for example "frontend" maps to software development). If a precise term returns nothing, paste a category or search URL into `startUrls` for exact control.
- **Use a country for `location`** — country-level locations like "United States", "United Kingdom", or "Canada" give the most reliable results; for city-level targeting, dial the search in on Learn4Good and paste the URL into `startUrls`.
- **Pair filters with a focused keyword** — job-type and posting-date filters scan listings as they come in, so combining them with a specific keyword returns matches faster than running them on a broad category. With a filter active, a search stops early once several pages in a row contain no matching jobs, so pick the most focused keyword for the best coverage.
- **Keep `fetchDescription` on when filtering by date or type** — those filters rely on detail-page data, so full pages are fetched automatically when either is set; leave the toggle on for the most complete rows.
- **Turn off `fetchDescription` for quick scans** — when you only need title, company, location, salary, and posting date, switching it off makes runs about 3× faster.
- **Batch related keywords in one run** — add several roles to `searchQueries` (up to 50) to sweep a whole sector in a single run; each gets its own search and results are deduplicated by job ID.
- **Set `maxResultsPerQuery` to control volume** — the whole final page is always kept, so the final count can land slightly above the cap on a small limit and slightly below it after duplicates are removed.
### Pricing
**From $10.00 per 1,000 results** — competitively priced for clean, structured Learn4Good job data with parsed salaries and full descriptions. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.
| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $1.20 | $1.13 | $1.07 | $1.00 |
| 1,000 | $12.00 | $11.30 | $10.65 | $10.00 |
| 10,000 | $120.00 | $113.00 | $106.50 | $100.00 |
| 100,000 | $1,200.00 | $1,130.00 | $1,065.00 | $1,000.00 |
A result is one job posting row in your 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 scraper collects publicly available job-listing data from Learn4Good. Use it responsibly and in compliance with Learn4Good's terms of service and all applicable laws and regulations. Do not use collected data to send unsolicited communications or for any purpose that infringes on privacy or other rights. You are responsible for how you use the data you collect, including any handling of personal information under regulations such as GDPR and CCPA.
# Actor input Schema
## `searchQueries` (type: `array`):
Job titles, roles, or keywords to search for, such as 'nurse', 'teacher', or 'warehouse'. Each keyword runs its own search. Leave empty if you are pasting direct URLs below instead. Up to 50 keywords per run.
## `location` (type: `string`):
City, state, or country to search in, such as 'New York', 'California', or 'United States'. Applies to every keyword above. Leave empty to search everywhere.
## `startUrls` (type: `array`):
Paste full Learn4Good search-result or individual job URLs (e.g. https://www.learn4good.com/jobs/) to scrape them directly. Useful when you already have a search dialed in on the website — any filters in the URL are kept. Up to 50 URLs per run.
## `jobType` (type: `string`):
Only return jobs of this employment type. Leave on 'Any' to include all types. With a job-type filter active, a search stops early if several pages in a row contain no matching jobs.
## `postedWithinDays` (type: `string`):
Only return jobs published within this time window. Leave on 'Any time' to include all listings. With a posting-date filter active, a search stops early if several pages in a row contain no matching jobs.
## `maxResultsPerQuery` (type: `integer`):
Maximum number of jobs to collect per search keyword or per URL. Results are fetched page by page: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return up to a full page more than you asked for. Jobs repeated across pages are removed, so the final count can also run slightly below your cap. As a safety limit, a single search collects at most about 10,000 jobs even if you set a higher cap — well above any Learn4Good category, which runs out of listings long before that.
## `fetchDescription` (type: `boolean`):
Fetch the full job description (plain text and HTML) and any extra detail from each job's own page. Leave on for the most complete data. Turn off to make runs about 3x faster — but the descriptionText and descriptionHtml fields will be empty.
## Actor input object example
```json
{
"searchQueries": [
"nurse"
],
"startUrls": [],
"jobType": "",
"postedWithinDays": "",
"maxResultsPerQuery": 100,
"fetchDescription": true
}
```
# Actor output Schema
## `overview` (type: `string`):
Table of scraped job listings with key fields like title, company, location, salary, job type, and posting date.
## `detail` (type: `string`):
Complete job data including full descriptions, parsed salary fields, expiry date, and run metadata.
# 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": [
"nurse"
],
"location": "",
"startUrls": [],
"jobType": "",
"postedWithinDays": "",
"maxResultsPerQuery": 100,
"fetchDescription": true
};
// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/learn4good-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": ["nurse"],
"location": "",
"startUrls": [],
"jobType": "",
"postedWithinDays": "",
"maxResultsPerQuery": 100,
"fetchDescription": True,
}
# Run the Actor and wait for it to finish
run = client.actor("solidcode/learn4good-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": [
"nurse"
],
"location": "",
"startUrls": [],
"jobType": "",
"postedWithinDays": "",
"maxResultsPerQuery": 100,
"fetchDescription": true
}' |
apify call solidcode/learn4good-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=solidcode/learn4good-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Learn4Good Jobs Scraper",
"description": "[💰 $10.00 / 1K] Extract job listings from Learn4Good. Search by keyword and location, paste Learn4Good URLs directly, or filter by job type and posting date. Get structured jobs with titles, companies, locations, salaries, types, posting dates, and full descriptions — one clean row per posting.",
"version": "1.0",
"x-build-id": "a5RxKobhqmPbbxpgm"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/solidcode~learn4good-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-solidcode-learn4good-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~learn4good-scraper/runs": {
"post": {
"operationId": "runs-sync-solidcode-learn4good-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~learn4good-scraper/run-sync": {
"post": {
"operationId": "run-sync-solidcode-learn4good-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, roles, or keywords to search for, such as 'nurse', 'teacher', or 'warehouse'. Each keyword runs its own search. Leave empty if you are pasting direct URLs below instead. Up to 50 keywords per run.",
"items": {
"type": "string"
}
},
"location": {
"title": "Location",
"type": "string",
"description": "City, state, or country to search in, such as 'New York', 'California', or 'United States'. Applies to every keyword above. Leave empty to search everywhere."
},
"startUrls": {
"title": "Direct Learn4Good URLs",
"maxItems": 50,
"type": "array",
"description": "Paste full Learn4Good search-result or individual job URLs (e.g. https://www.learn4good.com/jobs/) to scrape them directly. Useful when you already have a search dialed in on the website — any filters in the URL are kept. Up to 50 URLs per run.",
"items": {
"type": "string"
}
},
"jobType": {
"title": "Job Type",
"enum": [
"",
"full-time",
"part-time",
"contract",
"internship",
"temporary",
"volunteer"
],
"type": "string",
"description": "Only return jobs of this employment type. Leave on 'Any' to include all types. With a job-type filter active, a search stops early if several pages in a row contain no matching jobs.",
"default": ""
},
"postedWithinDays": {
"title": "Posted Within",
"enum": [
"",
"1",
"3",
"7",
"30"
],
"type": "string",
"description": "Only return jobs published within this time window. Leave on 'Any time' to include all listings. With a posting-date filter active, a search stops early if several pages in a row contain no matching jobs.",
"default": ""
},
"maxResultsPerQuery": {
"title": "Max Results per Query",
"minimum": 1,
"type": "integer",
"description": "Maximum number of jobs to collect per search keyword or per URL. Results are fetched page by page: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return up to a full page more than you asked for. Jobs repeated across pages are removed, so the final count can also run slightly below your cap. As a safety limit, a single search collects at most about 10,000 jobs even if you set a higher cap — well above any Learn4Good category, which runs out of listings long before that.",
"default": 100
},
"fetchDescription": {
"title": "Fetch Full Job Descriptions",
"type": "boolean",
"description": "Fetch the full job description (plain text and HTML) and any extra detail from each job's own page. Leave on for the most complete data. Turn off to make runs about 3x faster — but the descriptionText and descriptionHtml fields will be empty.",
"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
}
}
}
}
}
}
}
}
}
}
```