# 500px Email Scraper (`scraper-mind/500px-email-scraper-fast`) Actor

500px email scraper to collect emails from photographer profiles and portfolios on 500px 📧📷 Ideal for photography outreach, collaborations, and building targeted photographer contact lists.

- **URL**: https://apify.com/scraper-mind/500px-email-scraper-fast.md
- **Developed by:** [Scraper Mind](https://apify.com/scraper-mind) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

### 💌 500px Email Scraper – Fast, Advanced & Cheapest

Welcome to the most efficient, advanced, and affordable 500px Email Scraper built to supercharge your photographer outreach and creative partnerships. Whether you're a creative agency, brand, recruiter, or marketplace, this 500px Email Scraper is your ultimate 500px email scraping tool to discover verified emails from public 500px profiles with precision.

Say goodbye to manual research and hello to automated 500px scraping. With the 500px Email Scraper, you can scrape 500px email contacts at scale, run bulk 500px Email scraping, and focus on what matters—closing deals, recruiting talent, and building partnerships.

With advanced filtering, blazing-fast performance, and unbeatable pricing, our 500px Email Scraper ensures you get high-quality leads without breaking the bank. Easily export 500px Email data in clean JSON/CSV and integrate it into your CRM, spreadsheets, or marketing workflow.

---

### 📥 Input Parameters Guide

Below is a comprehensive guide to input parameters for configuring the 500px Email Scraper:

| Parameter       | Type               | Description                                                                                                                        | Default                               | Best Practice                                                                                          |
|-----------------|--------------------|------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------|---------------------------------------------------------------------------------------------------------|
| `keywords`      | Array (Required)   | A list of keywords or queries to search for (e.g., niche, style, role).                                                            | ["manager", "founder"]                 | Use specific photography keywords (e.g., “wedding photographer”, “portrait”, “commercial”) + location. |
| `location`      | String (Optional)  | Location to filter search results (e.g., city, country).                                                                           | ""                                     | Target by city/region for local campaigns (e.g., “Toronto”, “Berlin”, “Sydney”).                      |
| `customDomains` | Array (Optional)   | Filter results by email domains (e.g., @gmail.com, @company.com).                                                                  | ["@gmail.com", "@yahoo.com"]           | Add domains you care about to refine results and improve conversion.                                   |
| `maxEmails`     | Integer (Optional) | Maximum number of emails to collect. Stops when reached. Helps control time and cost.                                              | 20                                     | Start with 50–200 for testing; increase for bulk 500px Email scraping.                                 |

Notes:
- You can run automated 500px scraping for longer by increasing the run timeout in Run Options (default: 3600s/1 hour).
- If results are limited, try broader keywords, add variations, or include more domains to improve 500px Email data extraction.

#### Example Input Configuration
```json
{
  "keywords": ["wedding photographer", "portrait photography"],
  "location": "Toronto",
  "customDomains": ["@gmail.com", "@outlook.com"],
  "maxEmails": 75
}
````

***

### 📤 Output Data Structure

The 500px Email Scraper delivers clean, structured JSON or CSV for seamless workflows and to export 500px Email data effortlessly.

| Field         | Description                                  | Importance |
|---------------|----------------------------------------------|------------|
| `keyword`     | The keyword used to find the profile.        | High       |
| `title`       | Profile title or display name.               | High       |
| `description` | Bio or profile description.                  | Medium     |
| `url`         | Link to the 500px profile.                   | High       |
| `email`       | Verified email address (publicly available). | High       |

#### Example Output JSON

```json
[
  {
    "keyword": "wedding photographer",
    "title": "Jane Doe Photography",
    "description": "Toronto-based wedding & lifestyle photographer. Capturing candid moments.",
    "url": "https://500px.com/p/janedoephoto",
    "email": "hello@janedoephoto.com"
  },
  {
    "keyword": "portrait photography",
    "title": "Studio North",
    "description": "Portraits, editorial, and commercial work. Available worldwide.",
    "url": "https://500px.com/p/studionorth",
    "email": "contact@studionorthstudio.com"
  }
]
```

***

### 🌟 Why Choose Our 500px Email Scraper?

#### 1. ⚡ Unmatched Speed and Efficiency

Our 500px Email Scraper is engineered for speed, enabling bulk 500px Email scraping with optimized concurrency, smart retries, and scalable workflows. Move from hours of manual work to minutes of automated 500px scraping.

#### 2. 🎯 Highly Targeted Search Results

Use keywords, location, and domain filters for precise 500px Email data extraction. Whether you need wedding photographers in Toronto or commercial shooters in Berlin, the 500px Email Scraper delivers accurate, targeted results.

#### 3. 💰 The Most Affordable Solution on the Market

Save more with the cheapest 500px email scraping tool that doesn’t compromise on quality. Control costs with the maxEmails limit, and export 500px Email data in one click.

#### 4. 🌍 Global Reach and Scalability

From local searches to worldwide campaigns, the 500px Email Scraper scales seamlessly. Perfect for agencies, marketplaces, and platforms needing bulk 500px Email scraping across regions.

#### 5. 🧠 Smart Domain Filtering

Focus on the domains that matter. Quickly scrape 500px email contacts using filters like @gmail.com or brand domains for your outreach.

#### 6. 🔌 API-First and Python-Friendly

- Integrate via the 500px Email Scraper API to automate pipelines and connect to your data stack.
- Built with reliability in mind, the 500px Email Scraper Python approach makes scripting and orchestration easy for engineers.

#### 7. 🛡️ Robust, Reliable, and Compliant

Designed for stability, resilience, and compliance with 500px public data scraping. Only publicly available data is collected.

***

### 🛠️ How It Works

1. Define your inputs: keywords, location, and custom domains for targeted 500px data scraping.
2. Apply filters: focus on specific niches and regions for better results with your 500px Email scraping tool.
3. Run the scraper: kick off automated 500px scraping—no manual steps required.
4. Review results: verified, public emails and links are compiled in a clean dataset.
5. Export your data: export 500px Email data in JSON/CSV and plug into your CRM, email platform, or Google Sheets.
6. Automate at scale: trigger via the 500px Email Scraper API or schedule with the 500px Email Scraper Python workflow.

***

### 💡 Practical Use Cases for Your Business

- Photographer hiring and talent sourcing: find local or global creatives with verified contact details via 500px Email data extraction.
- Brand partnerships and influencer outreach: identify photographers by niche, style, and region; scrape 500px email contacts for campaigns.
- Marketplace onboarding: recruit high-quality creators for stock marketplaces or print stores using bulk 500px Email scraping.
- Media, editorial, and agencies: build curated lists for special projects with automated 500px scraping.
- Workshops and event organizers: build location-based outreach lists to fill seats and expand programs.
- CRM enrichment: export 500px Email data and enrich your CRM with profile links, descriptions, and emails.

***

### 📈 Maximizing Your ROI: Best Practices for Photographer Outreach

- Personalize your email with the photographer’s name and portfolio context.
- Reference recent work from their 500px profile to build rapport.
- State your value proposition within the first two sentences.
- Include a clear CTA: collaboration details, availability, or a booking link.
- Follow up politely after 2–4 days.
- Segment by niche and location for higher response rates.
- Use domain filters for cleaner lists and better deliverability.

***

### ❓ Frequently Asked Questions (FAQ)

1. Is this tool legal?
   Yes. The 500px Email Scraper collects only publicly available information. It’s designed for 500px public data scraping and respects robots and platform guidelines.

2. Does this use the official 500px API?
   No. It performs 500px public data scraping from public pages. You can, however, programmatically access results via the 500px Email Scraper API provided by the platform.

3. How fast is the scraper?
   Performance depends on input size and filters, but it’s optimized for bulk 500px Email scraping at scale with smart concurrency and throttling.

4. Can I filter by location?
   Yes. Use the location parameter to target cities, regions, or countries for more relevant 500px data scraping.

5. Can I filter by email domain?
   Absolutely. Add customDomains (e.g., @gmail.com, @company.com) to refine your 500px Email data extraction.

6. How accurate is the data?
   We extract only publicly listed emails from 500px profiles and surface them in a structured dataset. Not all profiles have public emails.

7. Can I integrate this with my CRM or workflow?
   Yes. You can export 500px Email data to JSON/CSV and push it to CRMs, spreadsheets, or BI tools. Use the 500px Email Scraper API for automation.

8. Do I need proxies?
   For larger runs or strict geotargeting, residential proxies are recommended to ensure consistent automated 500px scraping.

9. Is there a Python option?
   Yes. Run it via the 500px Email Scraper Python approach by calling the API from your Python scripts for orchestration and pipelines.

10. Can I run this in bulk?
    Yes—set higher maxEmails and schedule jobs for ongoing bulk 500px Email scraping across multiple niches and locations.

***

### 🔧 Troubleshooting Common Issues

1. No results found:
   - Broaden your keywords (e.g., “wedding photographer” instead of “elopement photographer”).
   - Remove overly restrictive domain filters.
   - Try different or additional locations.

2. Slow performance:
   - Lower the maxEmails value for test runs.
   - Reduce the number of keywords per run.
   - Use steady, reliable proxies for automated 500px scraping at scale.

3. Few or no emails:
   - Not all 500px users list public emails.
   - Add customDomains like @gmail.com or @outlook.com.
   - Expand your niche or location scope to enhance 500px Email data extraction.

4. Duplicate contacts:
   - Export 500px Email data and use your CRM’s deduplication or dataset unique keys.

***

### 📞 Support, Feedback & Custom Solutions

Have questions, feature requests, or need a bespoke workflow? Whether you’re building a marketplace onboarding pipeline, recruitment engine, or analytics feed, we can help integrate the 500px Email Scraper API or implement a tailored 500px Email Scraper Python solution for your stack. Reach out for consultation and custom development.

***

#### Key Features Summary

- ✅ Fast and efficient 500px Email scraping tool for targeted lead generation.
- ✅ Affordable and scalable bulk 500px Email scraping.
- ✅ Filters by keyword, location, and domain for precise results.
- ✅ Automated 500px scraping with API and scheduling support.
- ✅ Clean JSON/CSV outputs to export 500px Email data instantly.
- ✅ Robust, reliable 500px public data scraping with smart retries.
- ✅ Developer-friendly: 500px Email Scraper API and 500px Email Scraper Python workflows.

Take your creative sourcing and outreach to the next level with the 500px Email Scraper—start finding high-quality leads in minutes.

***

For any help or custom solution, contact via this mail: scrapermindapi@gmail.com

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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 = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-mind/500px-email-scraper-fast").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 = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-mind/500px-email-scraper-fast").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 '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraper-mind/500px-email-scraper-fast --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraper-mind/500px-email-scraper-fast",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "500px Email Scraper",
        "description": "500px email scraper to collect emails from photographer profiles and portfolios on 500px 📧📷 Ideal for photography outreach, collaborations, and building targeted photographer contact lists.",
        "version": "1.0",
        "x-build-id": "SO0WWh9dFMg8DekmV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-mind~500px-email-scraper-fast/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-mind-500px-email-scraper-fast",
                "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/scraper-mind~500px-email-scraper-fast/runs": {
            "post": {
                "operationId": "runs-sync-scraper-mind-500px-email-scraper-fast",
                "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/scraper-mind~500px-email-scraper-fast/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-mind-500px-email-scraper-fast",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
