# Greece Diavgeia Decisions Scraper (`parseforge/greece-diavgeia-decisions-scraper`) Actor

Tap the Greek Diavgeia transparency program for decisions published by public bodies. Returns ADA code, subject, decision type, protocol number, issuing organization, and issue date. Filter by organization, type, or date for audits, procurement tracking, and policy research.

- **URL**: https://apify.com/parseforge/greece-diavgeia-decisions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (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 $5.43 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏛️ Greece Diavgeia Public Decisions Scraper

> 🚀 **Export published Greek public-sector decisions in seconds.** Pull decisions from the Diavgeia transparency program by organization, decision type, and date, newest first.

> 🕒 **Last updated:** 2026-07-14 · **📊 Up to 21 fields** per record · newest-first feed · filter by org, type, and date

Turn the Greek Diavgeia transparency program into clean, structured records you can drop into an audit trail, a procurement tracker, or a policy-research dataset. The Actor walks the open-data decisions feed newest first, applies your filters, and returns one tidy record per published decision.

Coverage is the public Diavgeia catalog of decisions published by Greek public bodies: the ADA code, subject, decision type, protocol number, issuing organization, issue date, signers, thematic categories, and a direct link to the decision document.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Auditors and compliance teams | Trace decisions by organization and date |
| Procurement and bid trackers | Monitor tenders, awards, and contracts |
| Policy researchers and journalists | Study public-sector activity over time |
| Civic-tech and transparency builders | Power a public decisions dataset |

### 📋 What the Diavgeia Decisions Scraper does

This Actor calls the public Diavgeia open-data search feed and returns one clean record per decision:

- **Newest first** — the feed is walked from the most recent decisions, paging as needed.
- **Filter what you pull** — narrow by decision type, issuing organization, and a date range.
- **Document links included** — each record carries a direct URL to the decision document.

You control the filters and how many records come back. Every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |
| `decisionType` | select | Limit to a single Diavgeia decision type code (for example `Δ.1` for contract awards). Empty includes every type. |
| `organizationId` | string | Limit to one issuing body by its Diavgeia organization UID (for example `99202041`). Empty includes every organization. |
| `fromDate` | string | Only decisions submitted on or after this date. Format `YYYY-MM-DD`. |
| `toDate` | string | Only decisions submitted on or before this date. Format `YYYY-MM-DD`. |

**Example 1 — latest decisions, no filters**
```json
{
    "maxItems": 50
}
````

**Example 2 — contract awards from one organization in a date range**

```json
{
    "decisionType": "Δ.1",
    "organizationId": "99202041",
    "fromDate": "2025-01-01",
    "toDate": "2025-12-31",
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** Decision types use the official Diavgeia type codes (for example `Α.1.1` is a law, `Δ.1` is a contract award, `Β.2.1` is an expense approval). The full list with Greek labels is in the input dropdown. Organization UIDs are listed at `https://diavgeia.gov.gr/opendata/organizations.json`. The feed is ordered newest first.

### 📊 Output

Each record represents one published decision:

| Field | Description |
|---|---|
| 🆔 `ada` | Diavgeia ADA code (unique decision identifier) |
| 📌 `subject` | Decision subject |
| 🏷 `decisionTypeId` | Decision type code |
| `status` | Decision status |
| 🔢 `protocolNumber` | Protocol number |
| 📅 `issueDate` | Issue date (`YYYY-MM-DD`) |
| 🏛 `organizationId` | Issuing organization UID |
| 🏢 `organizationName` | Issuing organization name |
| `organizationAfm` | Organization tax ID (AFM) |
| `signerIds` | Array of signer IDs |
| `unitIds` | Array of unit IDs |
| `thematicCategoryIds` | Array of thematic category IDs |
| `documentType` | Document type |
| `privateData` | Whether the decision contains private data |
| `publishTimestamp` | Publish timestamp (ISO) |
| `submissionTimestamp` | Submission timestamp (ISO) |
| `versionId` | Document version ID |
| 🔗 `documentUrl` | Direct link to the decision document |
| `attachmentCount` | Number of attachments |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — a decision**

```json
{
    "ada": "9ΩΖΠ46ΜΤΛ6-Φ7Β",
    "subject": "Έγκριση δαπάνης και διάθεση πίστωσης για προμήθεια υλικών.",
    "decisionTypeId": "Β.2.1",
    "status": "published",
    "protocolNumber": "1542",
    "issueDate": "2026-06-05",
    "organizationId": "99202041",
    "organizationName": "ΔΗΜΟΣ ΑΘΗΝΑΙΩΝ",
    "organizationAfm": "090051636",
    "signerIds": ["12345"],
    "unitIds": ["67890"],
    "thematicCategoryIds": ["ECONOMY"],
    "documentType": "Β.2.1",
    "privateData": false,
    "publishTimestamp": "2026-06-05T11:42:00.000Z",
    "submissionTimestamp": "2026-06-05T11:30:00.000Z",
    "versionId": "abc123",
    "documentUrl": "https://diavgeia.gov.gr/doc/9ΩΖΠ46ΜΤΛ6-Φ7Β",
    "attachmentCount": 1,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per decision, with a direct document link.
- Filter by organization, decision type, and date range.
- Newest-first feed, so you always start from the most recent decisions.
- Issuing organization name and tax ID resolved for you.
- No account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Document links | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Browsing the portal by hand | Hours | Manual | Manual | Constant |
| Writing your own feed client | Days | Depends | You own it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Greece Diavgeia Public Decisions Scraper.
3. Optionally set `decisionType`, `organizationId`, `fromDate`, and `toDate`.
4. Set `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Audit and compliance

| Goal | How this helps |
|---|---|
| Trace an organization's decisions | Filter by `organizationId` and date |
| Verify a decision by ADA | Each record carries the ADA and document link |

#### Procurement tracking

| Goal | How this helps |
|---|---|
| Monitor awards and contracts | Filter by award decision types |
| Watch a body's activity | Combine organization and date filters |

#### Policy research

| Goal | How this helps |
|---|---|
| Study public-sector output | Pull decisions across types over time |
| Group by theme | Use thematic category IDs |

#### Media and transparency

| Goal | How this helps |
|---|---|
| Surface new decisions | Re-run for the latest feed entries |
| Link to source documents | Use the document URL field |

### 🔌 Automating Diavgeia Decisions Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route decisions into sheets or databases.
- **Slack** to post new decisions when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** build a dataset of public-sector decisions for analysis.
- **Personal:** follow decisions from a local authority you care about.
- **Non-profit:** power a civic transparency project.
- **Experimentation:** prototype a public-records app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize decisions, group by organization, or flag procurement-related entries.

### ❓ Frequently Asked Questions

**Do I need a Diavgeia account or API key?**
No. The Actor reads the public Diavgeia open-data feed, which needs no login.

**What is an ADA code?**
It is the unique identifier Diavgeia assigns to each published decision; it also forms the document URL.

**How do I filter by decision type?**
Pick a type from the `decisionType` dropdown, which lists the official Diavgeia codes with Greek labels.

**How do I find an organization UID?**
Organization UIDs are listed at `https://diavgeia.gov.gr/opendata/organizations.json`. Put the UID in `organizationId`.

**What date format should I use?**
`YYYY-MM-DD` for both `fromDate` and `toDate`.

**In what order are decisions returned?**
Newest first, the same order the open-data feed uses.

**Can I get the decision document?**
Yes. Each record includes a `documentUrl` linking to the decision on Diavgeia.

**Are signers and categories included?**
Yes, as arrays of IDs (`signerIds`, `unitIds`, `thematicCategoryIds`).

**How fresh is the data?**
Each run pulls live from Diavgeia, so it reflects the latest published decisions at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the feed on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- More public-records and transparency Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Diavgeia or the Greek government. Only publicly available data is collected.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `decisionType` (type: `string`):

Limit results to a single Diavgeia decision type. Leave empty to include every type. Values are the official Diavgeia type codes.

## `organizationId` (type: `string`):

Limit results to a single issuing body, by its Diavgeia organization UID (for example '99202041'). Leave empty to include every organization. Organization UIDs are listed at https://diavgeia.gov.gr/opendata/organizations.json

## `fromDate` (type: `string`):

Only include decisions submitted on or after this date. Use the format YYYY-MM-DD (for example '2025-01-01'). Leave empty to start from the most recent decisions.

## `toDate` (type: `string`):

Only include decisions submitted on or before this date. Use the format YYYY-MM-DD (for example '2025-12-31'). Leave empty for no upper bound.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/greece-diavgeia-decisions-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/greece-diavgeia-decisions-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 '{
  "maxItems": 10
}' |
apify call parseforge/greece-diavgeia-decisions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Greece Diavgeia Decisions Scraper",
        "description": "Tap the Greek Diavgeia transparency program for decisions published by public bodies. Returns ADA code, subject, decision type, protocol number, issuing organization, and issue date. Filter by organization, type, or date for audits, procurement tracking, and policy research.",
        "version": "0.1",
        "x-build-id": "gkl3uIUVr6BdNr0OA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~greece-diavgeia-decisions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-greece-diavgeia-decisions-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/parseforge~greece-diavgeia-decisions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-greece-diavgeia-decisions-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/parseforge~greece-diavgeia-decisions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-greece-diavgeia-decisions-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "decisionType": {
                        "title": "Decision type",
                        "enum": [
                            "Α.1.1",
                            "Α.1.2",
                            "Α.3",
                            "Α.4",
                            "Α.5",
                            "Α.6",
                            "Β.1.1",
                            "Β.1.2",
                            "Β.1.3",
                            "100",
                            "Γ.3.3",
                            "Β.3",
                            "Ε.1",
                            "Α.7",
                            "2.4.7.1",
                            "Ε.2",
                            "Ε.3",
                            "Ε.4",
                            "Ζ.1",
                            "Γ.3.6",
                            "Γ.3.5",
                            "Δ.2.1",
                            "Γ.3.1",
                            "Γ.3.2",
                            "Β.2.1",
                            "Δ.2.2",
                            "Δ.1",
                            "Γ.3.4",
                            "Β.4",
                            "Β.5",
                            "Γ.2",
                            "Β.2.2",
                            "Α.2",
                            "Β.6",
                            "2.4.6.1"
                        ],
                        "type": "string",
                        "description": "Limit results to a single Diavgeia decision type. Leave empty to include every type. Values are the official Diavgeia type codes."
                    },
                    "organizationId": {
                        "title": "Organization ID",
                        "type": "string",
                        "description": "Limit results to a single issuing body, by its Diavgeia organization UID (for example '99202041'). Leave empty to include every organization. Organization UIDs are listed at https://diavgeia.gov.gr/opendata/organizations.json"
                    },
                    "fromDate": {
                        "title": "From date",
                        "type": "string",
                        "description": "Only include decisions submitted on or after this date. Use the format YYYY-MM-DD (for example '2025-01-01'). Leave empty to start from the most recent decisions."
                    },
                    "toDate": {
                        "title": "To date",
                        "type": "string",
                        "description": "Only include decisions submitted on or before this date. Use the format YYYY-MM-DD (for example '2025-12-31'). Leave empty for no upper bound."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
