# Scientific Table and Footnote Extractor (`flintglade/scientific-table-footnote-extractor`) Actor

Extract scientific tables, cells, units, and explicit footnotes from authorized HTML and born-digital PDF sources.

- **URL**: https://apify.com/flintglade/scientific-table-footnote-extractor.md
- **Developed by:** [Flintglade](https://apify.com/flintglade) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 extracted tables

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Scientific Table and Footnote Extractor

Extract evidence-linked tables from explicit, authorized HTML and born-digital PDF sources. Scanned pages return an uncharged `ocr_required` record; version 0.1 has no OCR.

### What this does not do

- No OCR, browser rendering, paywall bypass, or arbitrary article crawling.
- No automatic scientific interpretation.
- No conversion of censored symbols, ranges, missing markers, or footnotes into invented values.
- No rights determination beyond retaining source indicators and requiring the user's declaration.

### Sources and authorization

Each of the 1–50 sources must be an explicit HTTPS URL or a user-selected Apify key-value-store record. Every source requires a `rightsBasis` of `user_owned`, `open_license`, `public_domain`, or `permission` with evidence. AP-029 indicators may inform that declaration but never replace it.

The Actor validates public URLs against SSRF rules, limits redirects and response bytes, never follows article links, and accepts only detected HTML or PDF matching the declared hint. PDF support is bounded to born-digital pages; browser rendering and OCR are excluded.

### Input

```json
{
  "sources": [
    {
      "url": "https://flintglade-tools.github.io/apify-fixtures/tables/scientific-table.html",
      "rightsBasis": {
        "type": "user_owned",
        "evidence": "Flintglade-controlled public fixture"
      },
      "formatHint": "html"
    }
  ],
  "includeFootnotes": true,
  "retainRaw": false,
  "concurrency": 1
}
````

Optional `tableSelectors` target at most 20 HTML selectors. Optional `pageRanges` target at most 50 PDF ranges. They are mutually exclusive by format. `maxBytesPerSource` defaults to 50 MB and cannot exceed 100 MB; `maxPdfPages` defaults to 200 and cannot exceed 1,000; concurrency is 1–2.

### Output

Each admitted table creates one default-dataset result with a stable table ID, caption, section or page and bounding box, span-preserving cells, header graph, units, raw scientific symbols, parsed numeric candidates, explicit footnote links, unassigned nearby footnotes, source evidence, and canonical hashes.

```json
{
  "recordType": "result",
  "status": "extracted_table",
  "entity": {"key": "sft_35b...", "inputIndex": 0},
  "charge": {"event": "extracted-table", "chargeable": true},
  "data": {
    "caption": "Example values",
    "rowCount": 3,
    "columnCount": 2,
    "units": ["mg"],
    "artifacts": [
      {"key": "tables/sft_35b....json", "contentType": "application/json"},
      {"key": "tables/sft_35b....csv", "contentType": "text/csv"}
    ]
  }
}
```

JSON is authoritative. CSV is produced only for an admitted rectangular representation and prefixes spreadsheet-formula leaders in the display export while JSON preserves the raw value. KVS contains JSON and CSV per table, optional raw-value JSON, and `SOURCE_MANIFEST.json`, each referenced with byte length, SHA-256, schema version, and generation rule. Every run ends with one uncharged summary row.

### Pricing

The only business event is `extracted-table` at the documented launch price of **$0.05 per admitted table**. Maximum business-event cost is `admitted tables × $0.05`, plus Apify platform usage. Ten admitted tables cost at most $0.50 in business events; fifty cost at most $2.50. Captions, figures, false candidates, source failures, rights rejection, oversized inputs, parse failures, `ocr_required`, summaries, and charge-cap records are uncharged.

The price is economically sensible for launch because the charged unit is a schema-valid reusable table with JSON/CSV artifacts and provenance, while the 5-cent unit leaves operating headroom for the default 4 GB PDF workload and bounded retries without charging for failed work. Revisit price only after hosted cost-per-table, abort-rate, and customer-value evidence exists; do not lower safety ceilings to defend a price.

The Actor consults Apify's charging manager before reading. It stops scheduling and withholds further extracted value when the event limit is exhausted. The run summary reports the SDK-confirmed event count; `apify-default-dataset-item` must remain disabled.

The frozen publication gate covers 100 CC BY publisher-JATS tables split evenly between HTML and born-digital PDF. It records 0.991086 cell recall, 1.0 header accuracy, 24/24 explicit footnote links, 70/70 units, and zero invented links. See [benchmark/README.md](benchmark/README.md) for the review protocol and hashes. [PPE\_RECONCILIATION.md](PPE_RECONCILIATION.md) records every deterministic billing branch and isolates the one post-upload Console check; no hosted result is claimed before upload authorization.

### State and failure behavior

Version 0.1 is stateless. Stable table IDs derive from the raw source hash and evidence locator; canonical table hashes exclude run IDs, timestamps, retry metadata, and platform metadata. Source failures are explicit and do not suppress successful sibling sources. Ambiguous footnotes remain unassigned instead of being guessed.

### Resources and data handling

The launch profile is 1,024 MB minimum, 4,096 MB default, 8,192 MB maximum, and a 1,800-second hosted timeout. Source bodies are processed in memory under byte/page caps. Raw source bodies are not retained; `retainRaw` stores only raw extracted cell values. Dataset and KVS retention follow the user's Apify account policy and can be deleted in the Apify Console/API.

URLs are emitted with query values redacted. Secrets, cookies, authorization headers, and private storage tokens are never included in results. See [PRIVACY.md](PRIVACY.md), [SOURCE\_POLICY.md](SOURCE_POLICY.md), and [THREAT\_MODEL.md](THREAT_MODEL.md).

### Limitations

HTML span/header extraction is deterministic. PDF extraction uses text objects and geometry and will not recover image pixels, handwriting, or every visually implied layout. PDF footnotes without explicit marker evidence remain unassigned. Parsed numeric candidates do not replace raw text and are not scientific conclusions.

Support: support@flintglade.com. Release history is in [CHANGELOG.md](CHANGELOG.md).

# Actor input Schema

## `inputSchemaVersion` (type: `integer`):

Versioned runtime contract.

## `sources` (type: `array`):

Provide 1-50 explicit HTTPS URLs or user-selected KVS records. Every source requires a rights basis.

## `includeFootnotes` (type: `boolean`):

Retain explicit and nearby footnotes without inventing links.

## `retainRaw` (type: `boolean`):

Write a separate raw-value KVS artifact for each admitted table.

## `maxBytesPerSource` (type: `integer`):

Oversized sources are refused and uncharged.

## `maxPdfPages` (type: `integer`):

PDFs over this cap are refused before table extraction.

## `concurrency` (type: `integer`):

Bounded parallel source processing.

## Actor input object example

```json
{
  "inputSchemaVersion": 1,
  "sources": [
    {
      "url": "https://flintglade-tools.github.io/apify-fixtures/tables/scientific-table.html",
      "rightsBasis": {
        "type": "user_owned",
        "evidence": "Flintglade-controlled public fixture"
      },
      "formatHint": "html"
    }
  ],
  "includeFootnotes": true,
  "retainRaw": false,
  "maxBytesPerSource": 50000000,
  "maxPdfPages": 200,
  "concurrency": 1
}
```

# Actor output Schema

## `defaultDataset` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `sourceManifest` (type: `string`):

No description

## `tableArtifacts` (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 = {
    "sources": [
        {
            "url": "https://flintglade-tools.github.io/apify-fixtures/tables/scientific-table.html",
            "rightsBasis": {
                "type": "user_owned",
                "evidence": "Flintglade-controlled public fixture"
            },
            "formatHint": "html"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("flintglade/scientific-table-footnote-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 = { "sources": [{
            "url": "https://flintglade-tools.github.io/apify-fixtures/tables/scientific-table.html",
            "rightsBasis": {
                "type": "user_owned",
                "evidence": "Flintglade-controlled public fixture",
            },
            "formatHint": "html",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("flintglade/scientific-table-footnote-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 '{
  "sources": [
    {
      "url": "https://flintglade-tools.github.io/apify-fixtures/tables/scientific-table.html",
      "rightsBasis": {
        "type": "user_owned",
        "evidence": "Flintglade-controlled public fixture"
      },
      "formatHint": "html"
    }
  ]
}' |
apify call flintglade/scientific-table-footnote-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=flintglade/scientific-table-footnote-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Scientific Table and Footnote Extractor",
        "description": "Extract scientific tables, cells, units, and explicit footnotes from authorized HTML and born-digital PDF sources.",
        "version": "0.1",
        "x-build-id": "yMmlG3dMMFiwNmmOn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/flintglade~scientific-table-footnote-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-flintglade-scientific-table-footnote-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/flintglade~scientific-table-footnote-extractor/runs": {
            "post": {
                "operationId": "runs-sync-flintglade-scientific-table-footnote-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/flintglade~scientific-table-footnote-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-flintglade-scientific-table-footnote-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": [
                    "sources"
                ],
                "properties": {
                    "inputSchemaVersion": {
                        "title": "Input schema version",
                        "minimum": 1,
                        "maximum": 1,
                        "type": "integer",
                        "description": "Versioned runtime contract.",
                        "default": 1
                    },
                    "sources": {
                        "title": "Explicit authorized sources",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Provide 1-50 explicit HTTPS URLs or user-selected KVS records. Every source requires a rights basis.",
                        "items": {
                            "type": "object",
                            "additionalProperties": false,
                            "properties": {
                                "url": {
                                    "title": "Explicit URL",
                                    "description": "One public or user-authorized HTTPS HTML/PDF URL.",
                                    "type": "string",
                                    "maxLength": 2048
                                },
                                "kvsRecord": {
                                    "title": "KVS record",
                                    "description": "One explicitly selected key-value-store record.",
                                    "type": "object",
                                    "additionalProperties": false,
                                    "properties": {
                                        "key": {
                                            "title": "Record key",
                                            "description": "Exact record key to read without store enumeration.",
                                            "type": "string",
                                            "minLength": 1,
                                            "maxLength": 256,
                                            "pattern": "^[A-Za-z0-9!_.-]+$"
                                        },
                                        "storeId": {
                                            "title": "Store ID",
                                            "description": "Optional authorized store ID; omit for the run's default store.",
                                            "type": "string",
                                            "maxLength": 128
                                        }
                                    },
                                    "required": [
                                        "key"
                                    ]
                                },
                                "rightsBasis": {
                                    "title": "Rights basis",
                                    "description": "Required user declaration supporting authorized processing.",
                                    "type": "object",
                                    "additionalProperties": false,
                                    "properties": {
                                        "type": {
                                            "title": "Basis type",
                                            "description": "The user's authorization category; this is not a legal conclusion.",
                                            "type": "string",
                                            "enum": [
                                                "user_owned",
                                                "open_license",
                                                "public_domain",
                                                "permission"
                                            ]
                                        },
                                        "evidence": {
                                            "title": "Basis evidence",
                                            "description": "Concise evidence supporting the declaration.",
                                            "type": "string",
                                            "minLength": 3,
                                            "maxLength": 500
                                        }
                                    },
                                    "required": [
                                        "type",
                                        "evidence"
                                    ]
                                },
                                "formatHint": {
                                    "title": "Format",
                                    "description": "Expected media; runtime detection must agree.",
                                    "type": "string",
                                    "enum": [
                                        "html",
                                        "pdf"
                                    ]
                                },
                                "tableSelectors": {
                                    "title": "HTML table selectors",
                                    "description": "Optional bounded CSS selectors that must select table elements.",
                                    "type": "array",
                                    "minItems": 1,
                                    "maxItems": 20,
                                    "items": {
                                        "type": "string",
                                        "maxLength": 200
                                    }
                                },
                                "pageRanges": {
                                    "title": "PDF page ranges",
                                    "description": "Optional one-based inclusive page ranges.",
                                    "type": "array",
                                    "minItems": 1,
                                    "maxItems": 50,
                                    "items": {
                                        "type": "object",
                                        "additionalProperties": false,
                                        "properties": {
                                            "start": {
                                                "title": "Start page",
                                                "description": "First one-based page.",
                                                "type": "integer",
                                                "minimum": 1,
                                                "maximum": 1000
                                            },
                                            "end": {
                                                "title": "End page",
                                                "description": "Last one-based page.",
                                                "type": "integer",
                                                "minimum": 1,
                                                "maximum": 1000
                                            }
                                        },
                                        "required": [
                                            "start",
                                            "end"
                                        ]
                                    }
                                }
                            },
                            "required": [
                                "rightsBasis",
                                "formatHint"
                            ]
                        }
                    },
                    "includeFootnotes": {
                        "title": "Include footnotes",
                        "type": "boolean",
                        "description": "Retain explicit and nearby footnotes without inventing links.",
                        "default": true
                    },
                    "retainRaw": {
                        "title": "Retain raw values",
                        "type": "boolean",
                        "description": "Write a separate raw-value KVS artifact for each admitted table.",
                        "default": false
                    },
                    "maxBytesPerSource": {
                        "title": "Maximum bytes per source",
                        "minimum": 1024,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Oversized sources are refused and uncharged.",
                        "default": 50000000
                    },
                    "maxPdfPages": {
                        "title": "Maximum PDF pages",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "PDFs over this cap are refused before table extraction.",
                        "default": 200
                    },
                    "concurrency": {
                        "title": "Source concurrency",
                        "minimum": 1,
                        "maximum": 2,
                        "type": "integer",
                        "description": "Bounded parallel source processing.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
