# EFSA Scraper — EU Food Safety News & Scientific Data (`studio-amba/efsa-scraper`) Actor

Collect news, scientific opinions, and publications from the European Food Safety Authority (EFSA). Structured data with titles, dates, categories, and tags.

- **URL**: https://apify.com/studio-amba/efsa-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Other
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## EFSA Scraper — Extract EU Food Safety Alerts and Scientific Opinions

Scrape news articles, scientific opinions, risk assessments, and publications from the European Food Safety Authority (EFSA) at efsa.europa.eu. Stay on top of food safety developments across the European Union.

### What is EFSA Scraper?

The European Food Safety Authority (EFSA) is the EU's independent scientific agency that assesses risks related to the food chain. It publishes hundreds of scientific opinions, risk assessments, guidance documents, and news updates every year — covering everything from pesticide residues and food additives to animal health and GMOs.

EFSA Scraper extracts this content into structured, searchable data so your team can monitor food safety developments without manually browsing the EFSA website:

- **Food safety officers** at manufacturers track new EFSA opinions on ingredients and additives used in their products
- **Regulatory affairs teams** monitor EFSA publications to anticipate upcoming EU food regulation changes
- **Agricultural compliance specialists** follow pesticide and contaminant assessments that impact crop protection strategies
- **Public health researchers** collect EFSA's scientific output for systematic reviews and meta-analyses
- **Quality managers in food retail** build automated alerts when EFSA issues guidance on topics affecting their supply chain (e.g., salmonella, listeria, aflatoxins)

### What data does EFSA Scraper extract?

Each article or publication includes:

- 📰 **title** — Full title of the article, opinion, or publication
- 📅 **date** — Publication date (ISO format)
- 🏷️ **category** — Topic area or section (e.g., "Food safety", "Animal health", "Plant health")
- 📄 **type** — Content type (e.g., "NewsArticle", "ScientificOpinion", "SupportingPublication")
- 📝 **description** — Summary or abstract of the content
- 🔗 **url** — Direct link to the full article on EFSA
- 🖼️ **imageUrl** — Associated image URL when available
- 🏷️ **tags** — Keywords and topic tags assigned by EFSA
- 🕐 **scrapedAt** — ISO timestamp of extraction

### How to scrape EFSA

Configure your scrape with these input parameters:

| Parameter | Type | Description |
|-----------|------|-------------|
| **Start URLs** | Array | Specific EFSA pages to scrape. Defaults to the news page. You can also target scientific output listings. |
| **Search Query** | String | Search for topics or substances. Examples: `salmonella`, `pesticides`, `food additives`, `acrylamide`. |
| **Max Results** | Integer | Maximum articles to return (1-10,000). Default: 100. |
| **Proxy Configuration** | Object | Proxy settings for improved reliability. |

#### Tips for best results

- **Search by substance name** — enter `bisphenol A` or `glyphosate` to find all EFSA opinions and news about that substance
- **Use Start URLs** to target specific sections — paste the scientific output listing URL to scrape only formal opinions
- **Leave Search Query empty** to get all recent news and publications from the EFSA homepage
- **Combine with scheduled runs** to build a weekly digest of new EFSA publications delivered to your inbox or Slack
- **Start small** with 20-30 results to understand the data format before running larger extractions

### Output

Each article is returned as a JSON object. Here is a realistic example:

```json
[
  {
    "title": "Update of the risk assessment of nickel in food and drinking water",
    "date": "2026-03-15",
    "category": "Food safety",
    "type": "ScientificOpinion",
    "description": "Following a request from the European Commission, the EFSA Panel on Contaminants in the Food Chain (CONTAM Panel) updated its 2020 risk assessment of nickel in food and drinking water. The Panel established a tolerable daily intake (TDI) of 2.8 micrograms per kg body weight per day based on post-implantation loss in a two-generation reproductive toxicity study in rats.",
    "url": "https://www.efsa.europa.eu/en/scientific-output/update-risk-assessment-nickel-food-drinking-water",
    "imageUrl": "https://www.efsa.europa.eu/sites/default/files/2026-03/nickel-assessment.jpg",
    "tags": ["nickel", "contaminants", "food safety", "drinking water", "TDI"],
    "scrapedAt": "2026-04-03T10:05:22.000Z"
  },
  {
    "title": "Salmonella control: EFSA proposes new EU targets for poultry",
    "date": "2026-03-10",
    "category": "Biological hazards",
    "type": "NewsArticle",
    "description": "EFSA has proposed new targets for reducing Salmonella prevalence in poultry flocks across the EU. The scientific opinion, requested by the European Commission, recommends lowering the maximum acceptable prevalence of Salmonella Enteritidis and Salmonella Typhimurium in laying hen flocks from 2% to 1%.",
    "url": "https://www.efsa.europa.eu/en/news/salmonella-control-efsa-proposes-new-eu-targets-poultry",
    "tags": ["salmonella", "poultry", "biological hazards", "food safety"],
    "scrapedAt": "2026-04-03T10:05:24.000Z"
  },
  {
    "title": "Safety assessment of the food enzyme xylanase from Trichoderma reesei strain XR-62",
    "date": "2026-03-05",
    "category": "Food ingredients and packaging",
    "type": "ScientificOpinion",
    "description": "The food enzyme xylanase (4-beta-D-xylan xylanohydrolase; EC 3.2.1.8) is produced with the non-genetically modified Trichoderma reesei strain XR-62 by Dyadic International. Based on the data provided, the Panel concluded that the food enzyme does not give rise to safety concerns under the intended conditions of use.",
    "url": "https://www.efsa.europa.eu/en/scientific-output/safety-assessment-food-enzyme-xylanase-trichoderma-reesei",
    "tags": ["food enzymes", "xylanase", "food ingredients", "safety assessment"],
    "scrapedAt": "2026-04-03T10:05:26.000Z"
  }
]
````

Results can be downloaded as JSON, CSV, Excel, XML, or accessed via the Apify API.

### How much does it cost?

EFSA Scraper runs on the Apify platform. You pay only for compute resources consumed.

| Scrape size | Estimated time | Estimated cost |
|-------------|---------------|----------------|
| 20 articles | ~1 minute | ~$0.02 |
| 100 articles | ~4 minutes | ~$0.08 |
| 500 articles | ~18 minutes | ~$0.35 |
| 2,000 articles | ~1 hour | ~$1.20 |

Apify's free tier includes $5 of monthly compute, more than enough for regular food safety monitoring.

### Can I integrate?

Yes. Route EFSA data directly into your existing workflows:

- **Google Sheets** — Auto-populate a shared spreadsheet with new EFSA opinions for your regulatory affairs team
- **Slack** — Get notified when EFSA publishes opinions about substances relevant to your products
- **Zapier** — Trigger document reviews when new scientific opinions appear in your tracked categories
- **Make (Integromat)** — Build pipelines that categorize EFSA output by relevance to your product lines
- **Webhooks** — Push new publications to your regulatory intelligence platform in real time

Set up integrations from the Apify console under the "Integrations" tab.

### Can I use it as an API?

Yes. Call EFSA Scraper programmatically from any language:

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/efsa-scraper").call(run_input={
    "searchQuery": "pesticides",
    "maxResults": 50,
})

for article in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{article['date']} | {article.get('type', 'N/A')} | {article['title'][:80]}")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('studio-amba/efsa-scraper').call({
    searchQuery: 'pesticides',
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(a => console.log(`${a.date} | ${a.type || 'N/A'} | ${a.title.slice(0, 80)}`));
```

### FAQ

#### What is EFSA?

The European Food Safety Authority (EFSA) is an independent EU agency established in 2002 that provides scientific advice on food and feed safety, nutrition, animal health and welfare, plant protection, and plant health. Based in Parma, Italy, EFSA assesses risks in the food chain and publishes its opinions to inform EU legislation. Its work underpins most EU food safety regulations.

#### How does EFSA Scraper work?

The scraper crawls EFSA's website at efsa.europa.eu, navigating news listings, scientific output pages, and search results. It extracts structured metadata from each article including title, date, category, description, keywords, and links. The scraper handles Drupal-based pagination automatically.

#### Is it legal to scrape EFSA?

EFSA is a public EU agency whose mandate includes transparent communication of scientific assessments. All content on efsa.europa.eu is published for public access without login requirements. The scraper accesses only publicly available pages and respects rate limits through built-in concurrency controls.

#### How to get EFSA scientific opinions data?

Use the **Start URLs** field and paste EFSA's scientific output page URL (e.g., `https://www.efsa.europa.eu/en/scientific-output`), or enter a topic in the **Search Query** field. The scraper returns structured data for each opinion including title, date, category, and description.

#### Is this an EFSA API alternative?

Yes. While EFSA has an OpenData portal for some datasets, it does not provide a general API for accessing its full publication archive. This scraper provides structured, programmatic access to EFSA's published content with output in JSON, CSV, or Excel format.

#### What is the difference between EFSA and RASFF?

EFSA provides **scientific risk assessments** — it evaluates whether a substance, ingredient, or practice is safe. RASFF (Rapid Alert System for Food and Feed) is a **notification system** for actual food safety incidents and non-compliances found in the market. EFSA informs policy; RASFF alerts to immediate hazards.

### Limitations

- The scraper extracts article metadata and descriptions, not full PDF documents or underlying datasets
- Scientific opinions with very technical content may have truncated descriptions — use the URL to access the full text
- Tags and categories depend on what EFSA has assigned to each article; some older content may have fewer tags
- The search functionality matches against EFSA's own search engine, so results depend on EFSA's indexing

### Other regulatory data scrapers

Building a food safety or regulatory intelligence system? These scrapers cover complementary databases:

- **[ECHA Scraper](https://apify.com/studio-amba/echa-scraper)** — EU chemicals database: substance registrations, CAS numbers, and hazard data
- **[Staatsblad Scraper](https://apify.com/studio-amba/staatsblad-scraper)** — Belgian Official Gazette: national laws and decrees implementing EU food regulations
- **[Safety Gate Scraper](https://apify.com/studio-amba/safetygate-scraper)** — EU non-food product safety alerts and recall notifications
- **[EUR-Lex Scraper](https://apify.com/studio-amba/eurlex-scraper)** — EU legislation: the regulations and directives that EFSA opinions feed into

### Your feedback

Have a suggestion or found a problem? Open an issue on the [Issues tab](https://console.apify.com/actors/studio-amba~efsa-scraper/issues). We use your feedback to improve data coverage and reliability.

# Actor input Schema

## `startUrls` (type: `array`):

EFSA pages to scrape. Example: https://www.efsa.europa.eu/en/news

## `searchQuery` (type: `string`):

Search for alerts or topics (e.g., 'salmonella', 'pesticides', 'food additives').

## `maxResults` (type: `integer`):

Maximum number of alerts/articles to return.

## `proxyConfiguration` (type: `object`):

Proxy settings for reliability.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.efsa.europa.eu/en/news"
    }
  ],
  "maxResults": 100
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.efsa.europa.eu/en/news"
        }
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "startUrls": [{ "url": "https://www.efsa.europa.eu/en/news" }] }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/efsa-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 '{
  "startUrls": [
    {
      "url": "https://www.efsa.europa.eu/en/news"
    }
  ]
}' |
apify call studio-amba/efsa-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EFSA Scraper — EU Food Safety News & Scientific Data",
        "description": "Collect news, scientific opinions, and publications from the European Food Safety Authority (EFSA). Structured data with titles, dates, categories, and tags.",
        "version": "0.1",
        "x-build-id": "48Ufj7WnIT8gaOwEQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~efsa-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-efsa-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/studio-amba~efsa-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-efsa-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/studio-amba~efsa-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-efsa-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "EFSA pages to scrape. Example: https://www.efsa.europa.eu/en/news",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for alerts or topics (e.g., 'salmonella', 'pesticides', 'food additives')."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of alerts/articles to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for reliability."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
