# Etymonline Word Etymology Scraper (`parseforge/etymonline-scraper`) Actor

Pull word etymologies from the Online Etymology Dictionary. Returns headword, part of speech, etymology essay, related cross-references, century of origin, and direct URL. Search by keyword or look up specific words. Useful for linguists, writers, dictionary apps.

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

## Pricing

from $13.00 / 1,000 result items

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

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

## 📜 Etymonline Word Etymology Scraper

> 🚀 **Pull word etymologies from the Online Etymology Dictionary: headword, etymology essay, century of origin, related words.**

> 🕒 **Last updated:** 2026-05-07 · **📊 11 fields** per record · **50,000+ word etymologies** · headword, part of speech, etymology essay, related cross-references, century of origin

The **Etymonline Word Etymology Scraper** pulls word histories from the Online Etymology Dictionary, the most cited free source for English word origins. Output includes the headword, part of speech, etymology essay (HTML and plain text), summary, century or period of origin, related cross-reference words, and direct URL to the source page.

The dictionary covers **50,000+ English words and phrases** with etymologies tracing roots through Old English, Middle English, French, Latin, Greek, Norse, and beyond. The Actor has two modes: search by keyword to discover related words, or look up a specific list of words directly.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Linguists, writers, content marketers, NLP/ML pipelines, vocabulary apps, language learners, journalists | Linguistic research, word-of-the-day newsletters, vocabulary apps, NLP training corpora, content writing on word origins |

---

### 📋 What the Etymonline Word Etymology Scraper does

Five filtering workflows in a single run:

- 🔍 **Search mode.** Search a keyword and return ranked word results.
- 📚 **Lookup mode.** Pass a list of words and pull each one's etymology directly.
- 📜 **Full essay text.** HTML and plain-text etymology with cross-references resolved.
- 📅 **Century detection.** Heuristic extraction of the period a word was first attested.
- 🔗 **Related words.** Cross-references parsed from the body.

> 💡 **Why it matters:** clean, server-side filtering and fresh data on every run.

---
### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>mode</code></td><td>string</td><td><code>"search"</code></td><td>search or lookup.</td></tr>
<tr><td><code>query</code></td><td>string</td><td><code>"hello"</code></td><td>Keyword to search across the dictionary.</td></tr>
<tr><td><code>words</code></td><td>string</td><td><code>newline list</code></td><td>Direct word lookup list.</td></tr>
</tbody>
</table>

**Example: search words related to language.**

```json
{
    "maxItems": 50,
    "mode": "search",
    "query": "language"
}
````

**Example: look up specific words.**

```json
{
    "maxItems": 10,
    "mode": "lookup",
    "words": "hello\nworld\nlanguage\netymology"
}
```

***

### 📊 Output

Each record contains **11 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🔤 `word` | string | `"hello"` |
| 📛 `headwordDisplay` | string | `"hello (interj.)"` |
| 🏷️ `partOfSpeech` | string | `"interj."` |
| 📜 `etymologyText` | string | `"greeting between strangers, especially through telephone..."` |
| 📜 `summary` | string | `"greeting between strangers..."` |
| 📅 `centuryFirstAttested` | string | null | `"1883"` |
| 🔗 `relatedWords` | array | `["hallo","holla","ahoy"]` |
| 🔢 `relatedCount` | number | `3` |
| 🔗 `etymonlineUrl` | string | `"https://www.etymonline.com/word/hello"` |

#### 📦 Sample records

<details>
<summary><strong>👋 Hello</strong></summary>

```json
{"word":"hello","headwordDisplay":"hello (interj.)","partOfSpeech":"interj.","summary":"greeting between strangers, originally a telephone greeting...","centuryFirstAttested":"1883","relatedWords":["hallo","holla","ahoy"]}
```

</details>

<details>
<summary><strong>📚 Language</strong></summary>

```json
{"word":"language","partOfSpeech":"n.","summary":"late 13c., \"words and phrases used by a people or nation\"...","centuryFirstAttested":"13c"}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📚 | **50,000+ words.** Most cited free etymology source online. |
| 📅 | **Century detection.** Heuristic period extraction for time-of-first-attestation analysis. |
| 🔗 | **Cross-references.** Related words parsed automatically. |
| ⚡ | **Fast.** 100 lookups in under a minute. |
| ⚖️ | **Public source.** Free public reference dictionary. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ This Actor** | $5 free credit | **50,000+** words | Live per run | search or direct list lookup | ⚡ 2 min |
| Manual etymonline browse | Free | Manual | Live | Web only | 🕒 Manual |
| OED API | $$ | Larger but paywalled | Live | Yes | 🐢 Subscription |
| Wiktionary scraping | Free | Mixed quality | Live | DIY | 🐢 Days |

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Find the Etymonline Word Etymology Scraper on the Apify Store.
3. 🎯 **Set input.** Pick filters and `maxItems`.
4. 🚀 **Run it.** Click **Start**.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📰 Content + Newsletters

- "Word of the day" content
- Vocabulary newsletter content
- Etymology-driven blog posts
- Trivia and curiosity articles

</td>
<td width="50%" valign="top">

#### 🎓 Education + Apps

- Vocabulary builder apps
- Language-learning supplements
- Etymology games
- Student reference tools

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🤖 NLP + ML

- Etymological feature engineering
- Train word-history classifiers
- Build linguistic-history embeddings
- Corpus enrichment

</td>
<td width="50%" valign="top">

#### 🔬 Linguistics Research

- First-attestation studies
- Loanword analyses
- Period-of-origin distributions
- Cross-language tracing

</td>
</tr>
</table>

***

### 🔌 Automating Etymonline Word Etymology Scraper

Control the scraper programmatically:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Computational linguistics
- Reproducible word-history snapshots
- Course materials
- Cross-period corpora

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal vocabulary databases
- Etymology blogs
- Side projects
- Newsletter content

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Cultural literacy outreach
- Educational accessibility
- Free reference compilation
- Heritage-language preservation

</td>
<td width="50%">

#### 🧪 Experimentation

- Train word-history classifiers
- Prototype etymology chat agents
- Build linguistic visualizations
- Test text-mining pipelines

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Etymonline%20Word%20Etymology%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Etymonline%20Word%20Etymology%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Etymonline%20Word%20Etymology%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Etymonline%20Word%20Etymology%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Search mode finds words related to a keyword via the dictionary's search index. Lookup mode fetches each word in your list directly. Each match returns the parsed etymology page.

#### 📚 How many words are in the dictionary?

50,000+ English words and phrases, with new entries added regularly by the maintainer.

#### 📊 How many fields per record?

11, including word, part of speech, etymology essay, summary, century of origin, related words, and source URL.

#### 📅 How accurate is century detection?

Heuristic. The Actor extracts the first matching `\d{2,4}c.` pattern from the etymology text. Always verify against the source for citations.

#### 🔗 Are related words bidirectional?

No. Relations are extracted from the current page's body. Reverse relations may not appear.

#### 🔁 Can I schedule runs?

Yes. New entries are added regularly; weekly schedules capture additions.

#### ⚖️ Is this data public?

Yes. Etymonline is a free public reference dictionary. The Actor reads only public pages.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers preview runs.

#### 🆘 What if a word isn't in the dictionary?

The lookup is skipped silently with a debug log. Etymonline covers most common English words but isn't exhaustive for rare/specialized vocabulary.

#### 🌐 Does it support languages other than English?

No. The dictionary tracks English words; entries reference foreign-language roots but only English headwords are indexed.

***

### 🔌 Integrate with any app

Etymonline Word Etymology Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets to Sheets

***

### 🔗 Recommended Actors

- [**📖 Dictionary Word Definitions**](https://apify.com/parseforge/dictionary-api-scraper) - English word definitions, phonetics, audio, synonyms
- [**📚 Project Gutenberg Books**](https://apify.com/parseforge/project-gutenberg-books-scraper) - 75,000+ free public-domain books
- [**📚 Open Library Editions**](https://apify.com/parseforge/openlibrary-editions-scraper) - Physical book editions with ISBN, publisher
- [**🌐 Wikidata Entity Search**](https://apify.com/parseforge/wikidata-entity-search-scraper) - 100M+ open knowledge-graph entities
- [**📊 Stack Exchange Questions**](https://apify.com/parseforge/stackexchange-questions-scraper) - Search 170+ Stack Exchange Q\&A sites

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Online Etymology Dictionary, its maintainers, or any cited reference work. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

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

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

## `mode` (type: `string`):

Search returns a ranked list of related words; lookup pulls each word in the list directly.

## `query` (type: `string`):

Keyword to search across the dictionary.

## `words` (type: `string`):

List of words, one per line or semicolon-separated. Each is fetched directly.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "search",
  "query": "hello",
  "words": "hello\nworld\nlanguage\netymology\ndictionary"
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10,
    "mode": "search",
    "query": "hello",
    "words": `hello
world
language
etymology
dictionary`
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/etymonline-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "mode": "search",
    "query": "hello",
    "words": """hello
world
language
etymology
dictionary""",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/etymonline-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "mode": "search",
  "query": "hello",
  "words": "hello\\nworld\\nlanguage\\netymology\\ndictionary"
}' |
apify call parseforge/etymonline-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etymonline Word Etymology Scraper",
        "description": "Pull word etymologies from the Online Etymology Dictionary. Returns headword, part of speech, etymology essay, related cross-references, century of origin, and direct URL. Search by keyword or look up specific words. Useful for linguists, writers, dictionary apps.",
        "version": "1.0",
        "x-build-id": "jFIXP4baS2quGjDse"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~etymonline-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-etymonline-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~etymonline-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-etymonline-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~etymonline-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-etymonline-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "lookup"
                        ],
                        "type": "string",
                        "description": "Search returns a ranked list of related words; lookup pulls each word in the list directly.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query (search mode)",
                        "type": "string",
                        "description": "Keyword to search across the dictionary."
                    },
                    "words": {
                        "title": "Word list (lookup mode)",
                        "type": "string",
                        "description": "List of words, one per line or semicolon-separated. Each is fetched directly."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
