# Wikipedia Category Scraper β Article Lists & Data (`logiover/wikipedia-category-scraper`) Actor
Extract structured article lists from any Wikipedia category page across 10 language editions. Get titles, URLs and optional first-paragraph summaries. Automatic subcategory discovery and multi-page navigation. No API key or authentication required.
- **URL**: https://apify.com/logiover/wikipedia-category-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 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
## Wikipedia Category Scraper β Article Lists, Summaries & Data API (No API Key)
    
Extract structured **article lists from any Wikipedia category** across **10 language editions** β English, German, French, Spanish, Italian, Japanese, Chinese, Russian, Portuguese and Arabic. Give the Actor a category name or URL (e.g. `Category:Machine_learning`) and it returns every listed article with **title, full Wikipedia URL, page ID, source category and an optional first-paragraph summary** in clean structured JSON. Automatic **multi-page navigation and one-level subcategory discovery** included. **Fast, no browser, no API key, no login.**
> ### π Why this Wikipedia scraper?
> **Every article in a category, in minutes** Β· thousands of article references per run Β· 10 language editions Β· optional AI-ready summaries Β· direct HTTP (no browser) Β· export to JSON / CSV / Excel. The unofficial **Wikipedia / MediaWiki API alternative** for knowledge graphs, SEO topic research and multilingual NLP datasets.
---
### β¨ What this Actor does / Key features
- π **Full category extraction** β every article listed on a category page (`Category:...`), typically 50β200 per page, with automatic pagination through multi-page categories.
- π **10 language editions** β scrape the same topic in English, German, French, Spanish, Italian, Japanese, Chinese, Russian, Portuguese or Arabic to build parallel corpora.
- π³ **Subcategory discovery** β automatically follows one level of subcategory links to walk deeper into Wikipedia's human-curated category tree.
- π **Optional article summaries** β flip `scrapeSummaries: true` to fetch each article's first paragraph, perfect as ready-to-use text for embeddings, RAG and NLP training.
- π **Clean references** β every row carries the article title, full canonical URL, Wikipedia internal `pageId`, source category name and category URL.
- ποΈ **Two ways to target** β pass full category URLs *or* just bare category names and the Actor builds the correct per-language URL for you.
- π¦ **Volume control** β cap the run with `maxArticles` (up to 2,000) so you pay only for what you need.
- β‘ **Direct HTTP extraction** β parses Wikipedia's clean, consistent HTML; no browser, no DOM guesswork, no MediaWiki API token or rate limit.
- π‘οΈ **Proxy friendly** β Wikipedia rarely blocks; Apify Proxy with datacenter groups works fine out of the box.
### π Quick start (3 steps)
1. **Configure** β paste one or more category names (e.g. `Machine_learning`) *or* full category URLs, and pick a `language` edition. Toggle `scrapeSummaries` if you want the first paragraph of each article.
2. **Run** β click **Start**. The Actor paginates each category, follows subcategories one level deep, and streams article records into your dataset.
3. **Get your data** β open the **Output** tab and export to **JSON, CSV, Excel or XML**, or pull it via the Apify API.
### π₯ Input
You only need **one** of `categoryNames` or `categoryUrls`. Everything else is optional.
#### Example β AI & machine-learning topic map (English)
```json
{
"categoryNames": ["Machine_learning", "Artificial_intelligence", "Large_language_models"],
"language": "en",
"scrapeSummaries": false,
"maxArticles": 500,
"proxyConfiguration": { "useApifyProxy": true }
}
````
#### Example β summaries for an NLP / RAG dataset
```json
{
"categoryUrls": [
{ "url": "https://en.wikipedia.org/wiki/Category:Deep_learning" },
{ "url": "https://en.wikipedia.org/wiki/Category:Neural_network_architectures" }
],
"scrapeSummaries": true,
"maxArticles": 300
}
```
#### Example β same topic in another language (multilingual corpus)
```json
{
"categoryNames": ["Apprentissage_automatique"],
"language": "fr",
"scrapeSummaries": true,
"maxArticles": 400
}
```
| Field | Type | Description |
|-------|------|-------------|
| `categoryUrls` | array | Full Wikipedia category page URLs, each as `{ "url": "β¦/Category:Name" }`. Use this **or** `categoryNames`. |
| `categoryNames` | array | Bare category names (no URL) β e.g. `Machine_learning`, `Artificial_intelligence`. The Actor builds the URL for the chosen `language`. |
| `language` | string | Wikipedia edition: `en`, `de`, `fr`, `es`, `it`, `ja`, `zh`, `ru`, `pt` or `ar`. Default `en`. |
| `scrapeSummaries` | boolean | Also fetch each article page and extract the first-paragraph summary. Default `false` (faster). |
| `maxArticles` | integer | Total article cap across all categories, 1β2000. Default `300`. |
| `proxyConfiguration` | object | Apify Proxy settings. Datacenter proxies are fine β Wikipedia is proxy-friendly. |
> **Finding a category:** open any Wikipedia article, scroll to the **Categories** bar at the bottom, and click one β the URL will read `β¦/wiki/Category:Some_Topic`. Copy either the full URL into `categoryUrls` or just the `Some_Topic` part into `categoryNames`. Underscores replace spaces.
### π€ Output
One row per article, exportable to JSON, CSV, Excel or XML. Here is a trimmed sample record:
```json
{
"type": "article",
"articleTitle": "Convolutional neural network",
"articleUrl": "https://en.wikipedia.org/wiki/Convolutional_neural_network",
"categoryName": "Deep learning",
"categoryUrl": "https://en.wikipedia.org/wiki/Category:Deep_learning",
"summary": "A convolutional neural network (CNN) is a regularized type of feed-forward neural network that learns features by itself via filter (or kernel) optimizationβ¦",
"pageId": "40409788",
"language": "en",
"scrapedAt": "2026-07-06T12:00:00Z"
}
```
π Full field reference (click to expand)
| Field | Description |
|-------|-------------|
| `type` | Record type, always `"article"` |
| `articleTitle` | Wikipedia article title (human-readable) |
| `articleUrl` | Full canonical URL to the article |
| `categoryName` | Name of the category this article was found in |
| `categoryUrl` | URL of the source category page |
| `summary` | First paragraph of the article (only when `scrapeSummaries: true`) |
| `pageId` | Wikipedia's internal, stable page ID |
| `language` | Wikipedia language edition code (`en`, `de`, `fr`, β¦) |
| `scrapedAt` | Scrape timestamp (ISO 8601) |
### π‘ Use cases
- **Knowledge-graph construction** β turn Wikipedia's human-curated category system into structured taxonomies and entity-relationship graphs.
- **SEO topic & content research** β map topic clusters and content silos; every category is a ready-made list of subtopics to build topical authority around.
- **NLP / RAG datasets** β with `scrapeSummaries: true`, collect clean first-paragraph text by topic for embeddings, classification and retrieval-augmented generation.
- **Multilingual corpora** β scrape the same subject across language editions to build parallel or cross-lingual datasets.
- **Directory & catalog building** β assemble structured lists of companies, technologies, historical figures or scientific concepts represented in Wikipedia.
- **Link building & outreach** β surface in-niche Wikipedia articles worth referencing or auditing for broken links.
### π₯ Who uses it
Data engineers & ML teams building training corpora Β· SEO and content-marketing agencies mapping topic clusters Β· academic and NLP researchers Β· knowledge-management and taxonomy teams Β· data journalists Β· anyone who needs a clean, structured slice of Wikipedia by subject.
### π° Pricing
This Actor runs on a simple **pay-per-result** model β you pay for the article records you extract, with no separate Apify platform fees to calculate. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### β Frequently Asked Questions
**Do I need a Wikipedia or MediaWiki API key?**
No. This Actor reads Wikipedia's public HTML pages directly, so there's no API key, no OAuth and no MediaWiki rate limit to manage β only an Apify account.
**Does Wikipedia have a public API?**
Wikipedia offers the MediaWiki API, but it's paginated, rate-limited and awkward for bulk category traversal. This Actor works as an unofficial **Wikipedia API alternative**: point it at a category and it returns a flat, structured list of every article with summaries and page IDs.
**How do I get a list of all articles in a Wikipedia category?**
Enter the category name or URL and the Actor returns every listed article with its title, full URL and internal page ID, automatically paginating multi-page categories and following one level of subcategory links.
**Can it fetch article text, not just the list?**
Yes β set `scrapeSummaries: true` and each article's first paragraph is added to the `summary` field, which is ideal ready-to-use text for embeddings and NLP.
**How deep does category crawling go?**
The Actor follows **one level** of subcategory links from each category page. To go deeper, feed the discovered subcategory URLs back into a second run.
**Which Wikipedia language editions are supported?**
Ten: English (`en`), German (`de`), French (`fr`), Spanish (`es`), Italian (`it`), Japanese (`ja`), Chinese (`zh`), Russian (`ru`), Portuguese (`pt`) and Arabic (`ar`).
**Is it legal to scrape Wikipedia?**
Wikipedia content is published under a free license (CC BY-SA) and this Actor only collects publicly available page data. You remain responsible for attribution and for using the data in line with Wikipedia's terms and applicable law.
#### How do I export Wikipedia category data to CSV or JSON?
Run the Actor, then export the resulting dataset as CSV, JSON, Excel or XML from the Apify console, or pull it via the Apify API.
#### Can I build a multilingual dataset from Wikipedia?
Yes. Run the same category name across different `language` editions (e.g. `en`, `de`, `fr`) to assemble a parallel, cross-lingual corpus of article references and summaries.
### π More data scrapers by logiover
Building datasets from public knowledge and media sources? Pair the Wikipedia scraper with the rest of the logiover research & social suite:
| Source | Actor |
|---|---|
| π° News | [Google News Scraper](https://apify.com/logiover/google-news-scraper) Β· [Hacker News Search](https://apify.com/logiover/hacker-news-search-scraper) |
| π¬ Film & TV | [IMDb Scraper](https://apify.com/logiover/imdb-scraper) Β· [TVmaze Scraper](https://apify.com/logiover/tvmaze-scraper) Β· [Letterboxd Reviews](https://apify.com/logiover/letterboxd-film-review-scraper) |
| π¬ Forums | [Reddit Search Scraper](https://apify.com/logiover/reddit-search-scraper) Β· [Stack Exchange Questions](https://apify.com/logiover/stack-exchange-questions-scraper) |
| πΊ YouTube | [YouTube Search Scraper](https://apify.com/logiover/youtube-search-scraper) Β· [YouTube Video Details](https://apify.com/logiover/youtube-video-details-scraper) |
| βοΈ Writing | [Substack Newsletter Scraper](https://apify.com/logiover/substack-newsletter-scraper) Β· [Dev.to Articles Scraper](https://apify.com/logiover/devto-articles-scraper) |
| π Research | [arXiv Paper Scraper](https://apify.com/logiover/arxiv-paper-scraper) Β· [Semantic Scholar Scraper](https://apify.com/logiover/semantic-scholar-research-scraper) |
π Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** β 180+ actors across real estate, jobs, crypto, social media & B2B data.
### β° Scheduling & integration
Schedule this Actor on Apify to refresh a knowledge dataset daily or weekly as Wikipedia categories grow. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your vector database, BI tools and webhooks through the Apify API. Connect it to **Make, n8n or Zapier** to build automated knowledge-ingestion pipelines.
### β Support & feedback
Found a bug or need an extra field? Open an issue on the **Issues** tab β response is usually fast. If this Actor saves you time, a **β
β
β
β
β
review** on the Store page genuinely helps and is hugely appreciated. π
### βοΈ Legal
This Actor extracts only publicly available Wikipedia data (published under CC BY-SA) and is intended for legitimate research, analytics and dataset-building use. You are responsible for proper attribution and for complying with Wikipedia's terms of use and any applicable local laws.
***
### π Changelog
#### 2026-07-06
- β¨ README overhaul: richer output sample with page IDs, ready-to-run example scenarios (topic maps, RAG summaries, multilingual corpora), full field reference, and a research & media cross-promo grid.
#### 2026-07-01
- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.
# Actor input Schema
## `categoryUrls` (type: `array`):
Wikipedia category page URLs to scrape. Each category page lists articles in that category. Use URLs like https://en.wikipedia.org/wiki/Category:Machine\_learning
## `categoryNames` (type: `array`):
Wikipedia category names (without the full URL). The actor will build the URL automatically. E.g. 'Machine\_learning', 'Artificial\_intelligence', 'Large\_language\_models'.
## `language` (type: `string`):
Wikipedia language edition to scrape.
## `scrapeSummaries` (type: `boolean`):
Also fetch each article page to extract the first paragraph summary.
## `maxArticles` (type: `integer`):
Maximum total number of articles to scrape across all categories.
## `proxyConfiguration` (type: `object`):
Wikipedia is generally proxy-friendly. Datacenter proxies work fine.
## Actor input object example
```json
{
"categoryUrls": [
{
"url": "https://en.wikipedia.org/wiki/Category:Machine_learning"
},
{
"url": "https://en.wikipedia.org/wiki/Category:Artificial_intelligence"
},
{
"url": "https://en.wikipedia.org/wiki/Category:Python_(programming_language)"
}
],
"categoryNames": [
"Machine_learning",
"Artificial_intelligence"
],
"language": "en",
"scrapeSummaries": false,
"maxArticles": 300,
"proxyConfiguration": {
"useApifyProxy": true
}
}
```
# Actor output Schema
## `type` (type: `string`):
Record type
## `articleTitle` (type: `string`):
Wikipedia article title
## `articleUrl` (type: `string`):
Full Wikipedia article URL
## `categoryName` (type: `string`):
Category name this article belongs to
## `categoryUrl` (type: `string`):
Category page URL
## `summary` (type: `string`):
First paragraph of the article
## `pageId` (type: `string`):
Wikipedia internal page ID
## `language` (type: `string`):
Wikipedia language edition
## `scrapedAt` (type: `string`):
Timestamp
# 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 = {
"categoryUrls": [
{
"url": "https://en.wikipedia.org/wiki/Category:Machine_learning"
},
{
"url": "https://en.wikipedia.org/wiki/Category:Artificial_intelligence"
},
{
"url": "https://en.wikipedia.org/wiki/Category:Python_(programming_language)"
}
],
"categoryNames": [
"Machine_learning",
"Artificial_intelligence"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/wikipedia-category-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 = {
"categoryUrls": [
{ "url": "https://en.wikipedia.org/wiki/Category:Machine_learning" },
{ "url": "https://en.wikipedia.org/wiki/Category:Artificial_intelligence" },
{ "url": "https://en.wikipedia.org/wiki/Category:Python_(programming_language)" },
],
"categoryNames": [
"Machine_learning",
"Artificial_intelligence",
],
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/wikipedia-category-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 '{
"categoryUrls": [
{
"url": "https://en.wikipedia.org/wiki/Category:Machine_learning"
},
{
"url": "https://en.wikipedia.org/wiki/Category:Artificial_intelligence"
},
{
"url": "https://en.wikipedia.org/wiki/Category:Python_(programming_language)"
}
],
"categoryNames": [
"Machine_learning",
"Artificial_intelligence"
]
}' |
apify call logiover/wikipedia-category-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/wikipedia-category-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Wikipedia Category Scraper β Article Lists & Data",
"description": "Extract structured article lists from any Wikipedia category page across 10 language editions. Get titles, URLs and optional first-paragraph summaries. Automatic subcategory discovery and multi-page navigation. No API key or authentication required.",
"version": "1.0",
"x-build-id": "yK9Z7ud847aOHda5N"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/logiover~wikipedia-category-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-logiover-wikipedia-category-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/logiover~wikipedia-category-scraper/runs": {
"post": {
"operationId": "runs-sync-logiover-wikipedia-category-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/logiover~wikipedia-category-scraper/run-sync": {
"post": {
"operationId": "run-sync-logiover-wikipedia-category-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": {
"categoryUrls": {
"title": "Category URLs",
"type": "array",
"description": "Wikipedia category page URLs to scrape. Each category page lists articles in that category. Use URLs like https://en.wikipedia.org/wiki/Category:Machine_learning",
"default": [],
"items": {
"type": "object",
"required": [
"url"
],
"properties": {
"url": {
"type": "string",
"title": "URL of a web page",
"format": "uri"
}
}
}
},
"categoryNames": {
"title": "Category Names",
"type": "array",
"description": "Wikipedia category names (without the full URL). The actor will build the URL automatically. E.g. 'Machine_learning', 'Artificial_intelligence', 'Large_language_models'.",
"default": [],
"items": {
"type": "string"
}
},
"language": {
"title": "Wikipedia Language",
"enum": [
"en",
"de",
"fr",
"es",
"it",
"ja",
"zh",
"ru",
"pt",
"ar"
],
"type": "string",
"description": "Wikipedia language edition to scrape.",
"default": "en"
},
"scrapeSummaries": {
"title": "Scrape Article Summaries",
"type": "boolean",
"description": "Also fetch each article page to extract the first paragraph summary.",
"default": false
},
"maxArticles": {
"title": "Max Articles",
"minimum": 1,
"maximum": 2000,
"type": "integer",
"description": "Maximum total number of articles to scrape across all categories.",
"default": 300
},
"proxyConfiguration": {
"title": "Proxy Configuration",
"type": "object",
"description": "Wikipedia is generally proxy-friendly. Datacenter proxies work fine.",
"default": {
"useApifyProxy": 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
}
}
}
}
}
}
}
}
}
}
```