# PhilGEPS Philippines Procurement Scraper (`jungle_synthesizer/philgeps-procurement-scraper`) Actor

Extract Philippine government bid opportunities and award notices from PhilGEPS (philgeps.gov.ph) — budget, contact info, awardee, and award amount in PHP

- **URL**: https://apify.com/jungle\_synthesizer/philgeps-procurement-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Lead generation, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## PhilGEPS Scraper — Philippine Government Procurement Data

Scrape open bid opportunities and award notices from the **Philippine Government Electronic Procurement System (PhilGEPS)** at [philgeps.gov.ph](https://philgeps.gov.ph). Extract approved budgets, procurement modes, contact persons, funding sources, classifications, and complete award details including awardee names and contract amounts — all structured and ready to export.

PhilGEPS is the mandatory procurement portal for all Philippine government agencies. It lists every public tender and contract award, covering Goods, Civil Works, and Consulting Services procurements from hundreds of national and local government units.

### What Data Does the PhilGEPS Scraper Extract?

#### Bid Opportunity Fields

| Field | Description |
|-------|-------------|
| `reference_number` | PhilGEPS bid notice reference number |
| `title` | Procurement title / description |
| `procuring_entity` | Government agency posting the bid |
| `classification` | Goods, Civil Works, or Consulting Services |
| `category` | Business category (e.g., Office Supplies, Road Construction) |
| `approved_budget` | Approved Budget of the Contract (ABC) in PHP |
| `currency` | Always `PHP` |
| `procurement_mode` | Competitive Bidding, Small Value Procurement, Negotiated, Shopping, Direct Contracting |
| `published_date` | Date the notice was published |
| `closing_date` | Bid submission deadline |
| `delivery_period` | Delivery or project duration in days |
| `contact_person` | BAC secretariat contact name |
| `funding_source` | Funding source (e.g., Regular Agency Fund, Foreign-Assisted) |
| `area_of_delivery` | Delivery or project location |
| `status` | Published, Closed, or Awarded |
| `control_number` | PhilGEPS internal control number |
| `lot_type` | Single Lot or Multiple Lots |
| `opportunity_url` | Direct URL to the notice on PhilGEPS |
| `scraped_at` | ISO 8601 timestamp of the scrape |

#### Award Notice Additional Fields

| Field | Description |
|-------|-------------|
| `award_amount` | Final contract amount awarded (PHP) |
| `awarded_to` | Name of the winning bidder / awardee |
| `award_date` | Date the contract was awarded |

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `dataType` | string | `opportunities` | `opportunities` — active bid notices; `awards` — completed contract awards |
| `maxItems` | integer | `50` | Maximum records to return (1–5000). Each listing page contains 20 records |
| `fetchDetails` | boolean | `true` | Fetch full detail pages for each record. Extracts budgets, contacts, and funding sources. Set to `false` for faster listing-only mode |
| `proxyConfiguration` | object | No proxy | Optional proxy configuration. PhilGEPS does not require proxies |

### Example Input

Scrape the latest 200 active bid opportunities with full detail data:

```json
{
    "dataType": "opportunities",
    "maxItems": 200,
    "fetchDetails": true
}
````

Scrape recent award notices (faster listing-only mode):

```json
{
    "dataType": "awards",
    "maxItems": 500,
    "fetchDetails": false
}
```

### Example Output

#### Bid Opportunity (with details)

```json
{
    "reference_number": "22101",
    "title": "Procurement of Office Supplies for Ministry Operational Requirements",
    "procuring_entity": "MINISTRY OF FINANCE AND BUDGET AND MANAGEMENT - BARMM",
    "classification": "Goods",
    "category": "Computer Equipment and Accessories",
    "approved_budget": 59953.41,
    "currency": "PHP",
    "published_date": "19-Apr-2026 12:00 AM",
    "closing_date": "22-Apr-2026 09:00 AM",
    "delivery_period": "30",
    "contact_person": "Entesar Moda",
    "funding_source": "Regular Agency Fund (01000000)",
    "procurement_mode": "Small Value Procurement",
    "area_of_delivery": "Cotabato",
    "status": "Published",
    "control_number": "0225",
    "lot_type": "Single Lot",
    "opportunity_url": "https://philgeps.gov.ph/Indexes/viewLiveTenderDetails/22101/OPEN_MORE",
    "scraped_at": "2026-04-20T14:09:02.792Z"
}
```

#### Award Notice (with details)

```json
{
    "reference_number": "19834",
    "title": "Supply and Delivery of Medicines and Medical Supplies",
    "procuring_entity": "PHILIPPINE CHILDREN'S MEDICAL CENTER",
    "classification": "Goods",
    "category": "Pharmaceuticals and Drugs",
    "approved_budget": 4500000.00,
    "currency": "PHP",
    "published_date": "10-Mar-2026 12:00 AM",
    "procurement_mode": "Competitive Bidding",
    "area_of_delivery": "Quezon City",
    "status": "Awarded",
    "award_amount": 4312500.00,
    "awarded_to": "MedTech Supply Corporation",
    "award_date": "15-Apr-2026",
    "opportunity_url": "https://philgeps.gov.ph/Indexes/viewAwardNotice/19834/MORE",
    "scraped_at": "2026-04-20T14:12:33.101Z"
}
```

### PhilGEPS Data Coverage

- **Active bid opportunities**: ~1,480 notices at any given time, updated daily
- **Award notices**: ~5,000 recent awards accessible without search filters
- **Procurement modes covered**: Competitive Bidding, Small Value Procurement, Negotiated Procurement, Shopping, Direct Contracting, and more
- **Agency types**: National government agencies, local government units (LGUs), state universities and colleges (SUCs), government-owned and controlled corporations (GOCCs)

### Performance and Rate Limits

| Mode | Speed (50 records) | Notes |
|------|--------------------|-------|
| Listing-only (`fetchDetails: false`) | ~5 seconds | Reference numbers, titles, entities, dates only |
| Full detail (`fetchDetails: true`) | ~30–45 seconds | All fields including budgets, contacts, funding |

PhilGEPS is a Philippine government server with no anti-bot measures, no rate limiting, and no geo-restrictions. No proxy is required. The server occasionally returns HTTP 500 errors on individual detail pages due to server instability — the scraper automatically retries these requests.

### Use Cases

- **Lead generation for government contractors**: Identify active bid opportunities by classification, procurement mode, or procuring agency before submission deadlines
- **Procurement intelligence**: Track which agencies are buying what, at what budget levels, and who is winning contracts
- **Competitive analysis**: Monitor which suppliers are being awarded contracts in your sector and at what price points
- **Government spending research**: Analyze public expenditure patterns across agencies, regions, and procurement categories
- **Compliance monitoring**: Track procurement activity for transparency and accountability research
- **Market entry research**: Assess the volume and value of Philippine government procurement in a specific industry vertical

### Frequently Asked Questions

**How do I scrape PhilGEPS bid notices?**

Set `dataType` to `opportunities` and `fetchDetails` to `true`. The scraper will paginate through the PhilGEPS open tenders listing and fetch each bid notice's detail page to extract the approved budget, contact person, and funding source.

**What is PhilGEPS?**

PhilGEPS (Philippine Government Electronic Procurement System) is the mandatory online procurement portal for all Philippine government agencies. It publishes all public tenders and contract awards in one place, covering billions of pesos in government spending annually.

**Do I need a proxy to scrape PhilGEPS?**

No. PhilGEPS has no Cloudflare protection, no IP rate limiting, and no geographic restrictions. The site is a standard government server accessible from any IP.

**How current is the PhilGEPS data?**

New tenders are posted daily by government agencies. The scraper fetches data live from philgeps.gov.ph at the time of the run — there is no caching. Run the actor daily or on a schedule to maintain a fresh dataset.

**How many records can I scrape?**

The `maxItems` parameter accepts up to 5,000. There are approximately 1,480 active bid opportunities and 5,000 recent award notices accessible without search filters at any given time.

**What is the difference between listing-only and detail mode?**

Listing-only (`fetchDetails: false`) returns the data visible in the paginated table: reference number, title, procuring entity, classification, procurement mode, and dates. Detail mode (`fetchDetails: true`) also fetches each record's individual page to add the approved budget, contact person, funding source, delivery location, and lot type.

**How much does this actor cost to run?**

Pricing is pay-per-result. Check the pricing tab on the Apify Store for current rates. A run fetching 500 records with full details typically completes in under 10 minutes.

***

Need custom filtering by agency, classification, or budget range? Get in touch.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

## `dataType` (type: `string`):

Type of procurement data to scrape. Opportunities = active bid notices. Awards = completed contract awards.

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

Maximum number of records to return. Each page has 20 listings.

## `fetchDetails` (type: `boolean`):

Fetch full detail pages for each listing to extract budgets, contacts, and full descriptions. Slower but provides complete data.

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

Optional proxy configuration. PhilGEPS typically does not require proxies.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "dataType": "opportunities",
  "maxItems": 50,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "dataType": "opportunities",
    "maxItems": 50,
    "fetchDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/philgeps-procurement-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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "dataType": "opportunities",
    "maxItems": 50,
    "fetchDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/philgeps-procurement-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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "dataType": "opportunities",
  "maxItems": 50,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jungle_synthesizer/philgeps-procurement-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PhilGEPS Philippines Procurement Scraper",
        "description": "Extract Philippine government bid opportunities and award notices from PhilGEPS (philgeps.gov.ph) — budget, contact info, awardee, and award amount in PHP",
        "version": "1.0",
        "x-build-id": "aGo9bSOGWKDlzCFMe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~philgeps-procurement-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-philgeps-procurement-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/jungle_synthesizer~philgeps-procurement-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-philgeps-procurement-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/jungle_synthesizer~philgeps-procurement-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-philgeps-procurement-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",
                "required": [
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "dataType": {
                        "title": "Data Type",
                        "enum": [
                            "opportunities",
                            "awards"
                        ],
                        "type": "string",
                        "description": "Type of procurement data to scrape. Opportunities = active bid notices. Awards = completed contract awards.",
                        "default": "opportunities"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of records to return. Each page has 20 listings.",
                        "default": 50
                    },
                    "fetchDetails": {
                        "title": "Fetch Detail Pages",
                        "type": "boolean",
                        "description": "Fetch full detail pages for each listing to extract budgets, contacts, and full descriptions. Slower but provides complete data.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy configuration. PhilGEPS typically does not require proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
