` elements (`role="grid"`) are not read; `no-tables` rows mention them when the HTML has them.
- In monitor mode, avoid two overlapping schedules with the same `watchName`.
### Support
Something missing or wrong? Open an issue in the Issues tab with the URL, the table and what you expected. This Actor is not affiliated with Wikipedia or any site named on this page.
# Actor input Schema
## `urls` (type: `array`):
Web pages whose HTML tables you want, one per line (1 to 1,000 per run). A URL without http:// or https:// is read as https://. The same URL given twice is read and charged once. If this is empty, the example page https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_population is used.
## `tableIndexes` (type: `array`):
Return only the nth
elements of the page, counted from 1 in page order (the same numbering as the index field of each table and of otherTables). Example: 1 and 3. Empty means every data table.
## `titleContains` (type: `string`):
Return only tables whose caption, aria-label or nearest heading above the table contains this text (case does not matter). Example: GDP.
## `columnContains` (type: `string`):
Return only tables that have a column whose name contains this text (case does not matter). Example: population.
## `minRows` (type: `integer`):
Skip tables with fewer data rows than this (1 to 100,000). Skipped tables are listed in otherTables.
## `includeLayoutTables` (type: `boolean`):
Also return tables that are used for page layout rather than data (one row or one column without header cells, only images, cells holding other tables or long paragraphs, role="presentation", navigation boxes). Off by default; they are listed in otherTables with the reason.
## `stripFootnotes` (type: `boolean`):
Remove footnote marks from cells and captions: Wikipedia-style \[1], \[a], \[note 3], \[citation needed], and reference marks (class reference or footnote, or text like \[2], \*, †). The number of marks removed is in footnotesRemoved. Turn off to keep the cell text exactly as shown.
## `includeTextValues` (type: `boolean`):
Return rowsText next to rows: the same rows with every cell as the text shown on the page (for example "$1,234.50" where rows has 1234.5). Turn off for smaller output.
## `includeCsv` (type: `boolean`):
Add a csv field to each table: RFC 4180 CSV with the column names as the first line and the cells as written.
## `includeLinks` (type: `boolean`):
Add a links field to each table: for each row, the first link (absolute URL) found in each cell, keyed by column name.
## `maxRowsPerTable` (type: `integer`):
Return at most this many data rows per table (1 to 100,000). Rows left out are counted in rowsTruncated.
## `onlyChanges` (type: `boolean`):
Return only pages where a selected table gained or lost rows since the last run with the same watch name, with only the tables that changed and the added rows in changes (plus pages new to the watch). The first run returns every page as the starting point. A change is re-read after 1.5 seconds and reported only if the table is the same in both reads; a table that differs between two reads a moment apart (live data) is not reported that time and is compared again next run. A run in which nothing changed returns a free row saying so and charges only the run start fee.
## `watchName` (type: `string`):
Name of the remembered state used to compare runs (letters, digits, dot, dash, underscore; up to 40). Setting it (or turning on monitor mode) fills changeType and changes. Use a different name for each list of pages you track on its own schedule. With monitor mode on and no name, the name "default" is used.
## `resetMonitoringState` (type: `boolean`):
Start this watch over: forget the remembered tables before this run, so every page is returned as a first check.
## `maxConcurrency` (type: `integer`):
How many pages are read in parallel (1 to 8).
## `requestTimeoutSecs` (type: `integer`):
How long to wait for one page to answer (5 to 60 seconds). HTTP 429, 500, 502, 503 and 504 are asked again up to two more times; a page that does not answer in time is asked once more.
## Actor input object example
```json
{
"urls": [
"https://en.wikipedia.org/wiki/List_of_largest_companies_by_revenue"
],
"minRows": 1,
"includeLayoutTables": false,
"stripFootnotes": true,
"includeTextValues": true,
"includeCsv": false,
"includeLinks": false,
"maxRowsPerTable": 10000,
"onlyChanges": false,
"resetMonitoringState": false,
"maxConcurrency": 4,
"requestTimeoutSecs": 20
}
```
# Actor output Schema
## `results` (type: `string`):
One row per page: every data table on the page as JSON (column names from the header rows, one object per row, numbers as numbers, the cells as written in rowsText), with each table's title, position, row and column counts, column types and the merged cells that were filled in. Tables not returned (layout, not selected) are listed with the reason. A page that robots.txt does not allow, that needs a sign-in, that shows a check page, or whose tables are drawn by JavaScript comes back as a free row that says why.
# 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 = {
"urls": [
"https://en.wikipedia.org/wiki/List_of_largest_companies_by_revenue"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("neverempty/html-table-to-json").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 = { "urls": ["https://en.wikipedia.org/wiki/List_of_largest_companies_by_revenue"] }
# Run the Actor and wait for it to finish
run = client.actor("neverempty/html-table-to-json").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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_largest_companies_by_revenue"
]
}' |
apify call neverempty/html-table-to-json --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,neverempty/html-table-to-json"
}
}
}
```
The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/actors/j5veOHOFnrEdkjDBE/builds/Lgfds05rlvvyALCAa/openapi.json