# HTML Table Extractor (`automation-lab/html-table-extractor`) Actor
Extract HTML tables from any webpage into structured JSON. Supports multiple URLs, filtering by CSS selector or table index, auto-header detection, and nested tables. Pure HTTP — no proxy needed.
- **URL**: https://apify.com/automation-lab/html-table-extractor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 3 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
Pay per event
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
## 🗂️ HTML Table Extractor
Extract structured data from any HTML `` on the web and download it as clean JSON or CSV — no coding required.
Whether you're a researcher pulling data from Wikipedia, a financial analyst scraping earnings tables, or a developer building a data pipeline, this actor turns messy HTML tables into structured, ready-to-use datasets in seconds.
---
### What does it do?
HTML Table Extractor fetches one or more URLs, finds all `` elements on each page, and converts them to structured JSON — one dataset item per table. It automatically detects column headers from `| ` tags, handles rowspans and colspans gracefully, and lets you filter by CSS selector, table index, or minimum row count.
**Example:** Extract the GDP rankings table from Wikipedia in one click. The actor fetches the page, identifies the right table, and outputs each row as a clean JSON object with named fields.
---
### Who is it for?
- 📊 **Data analysts** who regularly copy-paste tables from financial sites, government portals, or Wikipedia into spreadsheets
- 🧑💻 **Developers** building ETL pipelines that need structured data from HTML pages without writing custom parsers
- 📰 **Journalists and researchers** who need to extract comparison tables, statistics, or rankings from web pages
- 🏢 **Business intelligence teams** automating weekly data collection from partner or competitor websites
- 🤖 **AI/ML practitioners** who need structured training data or reference tables from the web
- 💼 **Operations teams** extracting pricing tables, product specs, or availability grids from supplier sites
---
### Why use HTML Table Extractor?
✅ **No proxy needed** — plain HTTP fetch works on most public web pages, keeping costs near zero
✅ **Smarter header detection** — auto-detects ` | ` headers OR lets you specify which row is the header
✅ **Filter precisely** — target tables by CSS selector, 0-based index, or minimum row count
✅ **Nested table support** — optionally extract tables inside other tables
✅ **Multiple URLs in one run** — batch many pages together
✅ **PPE pricing** — pay only for what you extract, with volume discounts for heavy users
✅ **Dataset-ready output** — every row is a flat JSON object, ready for Apify datasets, Google Sheets, or your own database
---
### 📋 What data can it extract?
| Field | Description | Example |
|-------|-------------|---------|
| `url` | Source page URL | `https://en.wikipedia.org/wiki/...` |
| `pageTitle` | Page `` text | `"List of countries by GDP (nominal)"` |
| `tableIndex` | 0-based position on page | `2` |
| `hasHeaders` | Whether headers were detected | `true` |
| `headers` | Array of column header names | `["Country", "GDP (USD)", "Year"]` |
| `rows` | Array of row objects | `[{"Country": "USA", "GDP (USD)": "28.7T"}]` |
| `rowCount` | Number of data rows extracted | `195` |
| `columnCount` | Number of columns | `4` |
---
### 💰 How much does it cost to extract HTML tables?
HTML Table Extractor uses **Pay-Per-Event (PPE)** pricing — you pay only for what you actually extract:
| Event | Price |
|-------|-------|
| Actor start | **$0.005** per run |
| Table extracted | **$0.0008** per table |
**Example costs:**
- Extract 10 tables from 3 URLs → $0.005 + (10 × $0.0008) = **$0.013**
- Extract 100 tables from Wikipedia → $0.005 + (100 × $0.0008) = **$0.085**
- Daily job extracting 50 tables → ~$0.045/day = **~$1.35/month**
**Volume discounts apply automatically** — heavy users (FREE → BRONZE → SILVER → GOLD → PLATINUM → DIAMOND tiers) get up to 60% off the base per-table price.
**Free tier:** Apify gives every account $5/month in free usage. That's enough to extract ~6,200 tables for free each month.
No proxy is used by default, so compute costs are minimal — just a lightweight HTTP fetch and cheerio HTML parsing.
---
### 🚀 How to use it — step by step
1. **Open** the actor at [apify.com/automation-lab/html-table-extractor](https://apify.com/automation-lab/html-table-extractor)
2. **Paste your URLs** — one or more pages containing HTML tables
3. **Optionally filter** — set a CSS selector (e.g. `#main-content`) or specify which table index to extract
4. **Click Run** — the actor fetches pages and extracts tables immediately
5. **Download results** — export as JSON, CSV, Excel, or send to Google Sheets via integration
**Tip:** Start with the pre-filled Wikipedia example to see output format before running on your own URLs.
---
### 📥 Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `urls` | array | ✅ Yes | — | List of page URLs to extract tables from |
| `tableSelector` | string | No | `""` | CSS selector to scope table search (e.g. `.main-content table`) |
| `tableIndices` | array | No | `[]` | Extract only tables at these 0-based positions (e.g. `[0, 2]`) |
| `minRows` | integer | No | `1` | Skip tables with fewer rows than this |
| `maxTablesPerPage` | integer | No | `100` | Maximum tables to extract per URL (0 = unlimited) |
| `headerRowIndex` | integer | No | `-1` | Row to use as headers (-1 = auto-detect from `<th>` tags) |
| `includeNestedTables` | boolean | No | `false` | Also extract tables nested inside other tables |
| `proxyConfiguration` | object | No | none | Optional proxy (not needed for most public sites) |
---
### 📤 Output example
Each extracted table becomes one dataset item:
```json
{
"url": "https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)",
"pageTitle": "List of countries by GDP (nominal) - Wikipedia",
"tableIndex": 2,
"hasHeaders": true,
"headers": ["Country/Territory", "IMF (2026)", "World Bank (2024)", "UN (2024)"],
"rows": [
{
"Country/Territory": "World",
"IMF (2026)": "123,584,494",
"World Bank (2024)": "111,326,370",
"UN (2024)": "100,834,796"
},
{
"Country/Territory": "United States",
"IMF (2026)": "31,821,293",
"World Bank (2024)": "28,750,956",
"UN (2024)": "29,298,000"
}
],
"rowCount": 195,
"columnCount": 4
}
````
***
### 💡 Tips & tricks
- **Wikipedia tables:** Most Wikipedia tables have `class="wikitable"`. Use `tableSelector: ".wikitable"` to skip navboxes and other small tables.
- **Multiple tables on a page:** Use `tableIndices: [1, 3]` to grab only the 2nd and 4th tables.
- **No headers detected?** If a table uses `<td>` for headers instead of `<th>`, set `headerRowIndex: 0` to treat the first row as headers.
- **Skip tiny navigation tables:** Set `minRows: 5` to ignore single-row tables that are really navigation elements.
- **Nested tables:** Enable `includeNestedTables` only if you specifically need data inside table cells that contain sub-tables — it can produce many more results.
- **Sites with JS-rendered tables:** This actor uses plain HTTP (no browser). If a table only appears after JavaScript runs, the actor won't see it. In that case, you'll need a browser-based scraper.
***
### 🔌 Integrations
HTML Table Extractor connects to your existing workflows:
**📊 Google Sheets** — Extract pricing tables or rankings directly into Sheets for weekly reporting. Use Apify's native Google Sheets integration to auto-append rows.
**🗃️ Database pipelines** — Send extracted JSON to PostgreSQL, MongoDB, or BigQuery via Apify's webhooks or the dataset API. Perfect for ETL jobs that run on a schedule.
**🤖 AI/ML pipelines** — Feed extracted tables to your LLM pipeline for summarization, Q\&A, or training data generation. Combine with the [AI Data Extractor](https://apify.com/automation-lab) for hybrid extraction.
**📅 Scheduled monitoring** — Run daily at 9am to check if a supplier's pricing table has changed. Pair with a webhook to Slack or email on data changes.
**📁 Excel/CSV exports** — All Apify datasets export to CSV and Excel natively — no extra steps needed.
***
### 🧑💻 API usage
#### Node.js
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('automation-lab/html-table-extractor').call({
urls: ['https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)'],
tableSelector: '.wikitable',
minRows: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```
#### Python
```python
from apify_client import ApifyClient
client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/html-table-extractor').call(run_input={
'urls': ['https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)'],
'tableSelector': '.wikitable',
'minRows': 5,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```
#### cURL
```bash
curl -X POST \
"https://api.apify.com/v2/acts/automation-lab~html-table-extractor/runs?token=YOUR_APIFY_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"urls": ["https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)"],
"tableSelector": ".wikitable",
"minRows": 5
}'
```
***
### 🤖 Use with AI agents via MCP
HTML Table Extractor is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).
Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:
#### Setup for Claude Code
```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```
#### Setup for Claude Desktop, Cursor, or VS Code
Add this to your MCP config file:
```json
{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com"
}
}
}
```
Your AI assistant will use OAuth to authenticate with your Apify account on first use.
#### Example prompts
Once connected, try asking your AI assistant:
- *"Use automation-lab/html-table-extractor to extract all tables from https://en.wikipedia.org/wiki/List\_of\_countries\_by\_population\_(United\_Nations) and show me the top 10 rows"*
- *"Extract the pricing table from https://example.com/pricing using the CSS selector .pricing-table"*
- *"Use the HTML table extractor to pull tables from these 5 Wikipedia pages and return only tables with more than 20 rows"*
Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).
***
### ⚖️ Legal & compliance
HTML Table Extractor fetches publicly accessible web pages using standard HTTP requests, similar to a browser visiting a page. It does not bypass authentication, CAPTCHA, or access controls.
**Always check:**
- The site's `robots.txt` before running at scale
- The site's Terms of Service regarding automated data collection
- Local laws governing web scraping and data usage in your jurisdiction
For academic research, journalism, and personal use on public data, web scraping is generally considered lawful in most jurisdictions. Commercial use may have additional requirements.
This actor does not store or share any data you extract — all data goes directly to your Apify dataset.
***
### ❓ FAQ
**Q: Does this work on sites that require JavaScript to render tables?**\
A: No — this actor uses plain HTTP (no browser). If a table is rendered client-side by JavaScript (e.g., React, Angular), the actor won't see it. Check if the table exists in the page's HTML source (Ctrl+U in Chrome). If not, you need a browser-based actor.
**Q: What if a table has merged cells (colspan/rowspan)?**\
A: Cells with `colspan` or `rowspan` are currently extracted as-is. The text from merged cells will appear in the first position they occupy. For complex layouts with many merged cells, the output may not perfectly reconstruct the visual table — this is a known limitation of flat HTML-to-JSON conversion.
**Q: I ran the actor but got 0 tables. What went wrong?**\
A: Common causes: (1) The tables are rendered by JavaScript — check the page HTML source. (2) Your CSS selector doesn't match any tables. (3) All tables were filtered out by `minRows`. Try running without a selector and with `minRows: 0` to see all tables.
**Q: Can I extract tables from PDFs?**\
A: No — this actor only handles HTML `<table>` elements on web pages. For PDF table extraction, see other actors in the Apify Store.
**Q: How many URLs can I process in one run?**\
A: There's no hard limit. Each URL is fetched sequentially. For large batches (100+ URLs), consider the 300-second default timeout — increase `timeoutSecs` in your run options if needed.
**Q: The actor found 12 tables but I only see data from one specific table. How do I target just that table?**\
A: Use `tableIndices` (e.g., `[3]` for the 4th table) or `tableSelector` with a specific CSS class or ID that wraps the table you want.
***
### 🔗 Related actors
- [HTML to Markdown](https://apify.com/automation-lab/html-to-markdown) — Convert any webpage's HTML content to clean Markdown text
- [CSV to JSON Converter](https://apify.com/automation-lab/csv-to-json-converter) — Convert CSV files or URLs to structured JSON datasets
- [JSON Schema Generator](https://apify.com/automation-lab/json-schema-generator) — Infer JSON Schema from any JSON data or API response
# Actor input Schema
## `urls` (type: `array`):
Enter one or more URLs to extract tables from. Each URL is fetched and all matching tables are extracted.
## `tableSelector` (type: `string`):
Optional CSS selector to scope table search (e.g. <code>#main-content table</code>). Leave blank to find all tables on the page.
## `tableIndices` (type: `array`):
Only extract tables at these 0-based positions on the page (e.g. <code>\[0, 2]</code> extracts the 1st and 3rd table). Leave blank to extract all tables.
## `minRows` (type: `integer`):
Skip tables with fewer data rows than this number. Useful to filter out small navigation tables.
## `maxTablesPerPage` (type: `integer`):
Maximum number of tables to extract per URL. Set to 0 for unlimited.
## `headerRowIndex` (type: `integer`):
Row index to treat as column headers (0 = first row, -1 = no header row, auto-detect from \<th> tags).
## `includeNestedTables` (type: `boolean`):
Also extract tables that are nested inside other table cells. By default, only top-level tables are extracted.
## `proxyConfiguration` (type: `object`):
Optional proxy settings. Most sites work without proxy — leave blank for direct HTTP requests.
## Actor input object example
```json
{
"urls": [
"https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)"
],
"tableIndices": [],
"minRows": 1,
"maxTablesPerPage": 100,
"headerRowIndex": -1,
"includeNestedTables": false
}
```
# 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 = {
"urls": [
"https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)"
],
"tableSelector": "",
"tableIndices": [],
"minRows": 1,
"maxTablesPerPage": 100,
"headerRowIndex": -1,
"includeNestedTables": false
};
// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/html-table-extractor").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 = {
"urls": ["https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)"],
"tableSelector": "",
"tableIndices": [],
"minRows": 1,
"maxTablesPerPage": 100,
"headerRowIndex": -1,
"includeNestedTables": False,
}
# Run the Actor and wait for it to finish
run = client.actor("automation-lab/html-table-extractor").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 '{
"urls": [
"https://en.wikipedia.org/wiki/List_of_countries_by_GDP_(nominal)"
],
"tableSelector": "",
"tableIndices": [],
"minRows": 1,
"maxTablesPerPage": 100,
"headerRowIndex": -1,
"includeNestedTables": false
}' |
apify call automation-lab/html-table-extractor --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=automation-lab/html-table-extractor",
"--header",
"Authorization: Bearer <YOUR_API_TOKEN>"
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "HTML Table Extractor",
"description": "Extract HTML tables from any webpage into structured JSON. Supports multiple URLs, filtering by CSS selector or table index, auto-header detection, and nested tables. Pure HTTP — no proxy needed.",
"version": "0.1",
"x-build-id": "4rSlH7xqFaAq9vc55"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/automation-lab~html-table-extractor/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-automation-lab-html-table-extractor",
"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/automation-lab~html-table-extractor/runs": {
"post": {
"operationId": "runs-sync-automation-lab-html-table-extractor",
"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/automation-lab~html-table-extractor/run-sync": {
"post": {
"operationId": "run-sync-automation-lab-html-table-extractor",
"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",
"required": [
"urls"
],
"properties": {
"urls": {
"title": "🌐 Page URLs",
"type": "array",
"description": "Enter one or more URLs to extract tables from. Each URL is fetched and all matching tables are extracted.",
"items": {
"type": "string"
}
},
"tableSelector": {
"title": "CSS Selector",
"type": "string",
"description": "Optional CSS selector to scope table search (e.g. <code>#main-content table</code>). Leave blank to find all tables on the page."
},
"tableIndices": {
"title": "Table indices",
"type": "array",
"description": "Only extract tables at these 0-based positions on the page (e.g. <code>[0, 2]</code> extracts the 1st and 3rd table). Leave blank to extract all tables."
},
"minRows": {
"title": "Minimum rows",
"minimum": 0,
"type": "integer",
"description": "Skip tables with fewer data rows than this number. Useful to filter out small navigation tables.",
"default": 1
},
"maxTablesPerPage": {
"title": "Max tables per page",
"minimum": 0,
"type": "integer",
"description": "Maximum number of tables to extract per URL. Set to 0 for unlimited.",
"default": 100
},
"headerRowIndex": {
"title": "Header row index",
"minimum": -1,
"type": "integer",
"description": "Row index to treat as column headers (0 = first row, -1 = no header row, auto-detect from <th> tags).",
"default": -1
},
"includeNestedTables": {
"title": "Include nested tables",
"type": "boolean",
"description": "Also extract tables that are nested inside other table cells. By default, only top-level tables are extracted.",
"default": false
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Optional proxy settings. Most sites work without proxy — leave blank for direct HTTP requests."
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```
|