# University People Finder (`hgservices/university-people-finder`) Actor

Extract professor emails, faculty contacts, and academic data from top universities of the world. Get names, emails, phones, departments, research areas, and profile URLs as CSV, JSON, or Excel.

- **URL**: https://apify.com/hgservices/university-people-finder.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** Lead generation, Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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

## University People Finder — Professor, Faculty & Academic Contact Extractor

Extract verified contact data for **professors, lecturers, researchers, and department heads** from top universities of the world. This university faculty finder gives you structured, ready-to-use academic contact data — no manual searching, no official API required.

Whether you're building a **professor email list** for EdTech outreach, identifying **higher education decision-makers** for B2B sales, or sourcing **academic contacts** for research collaboration — this Actor delivers the faculty data you need at scale.

### What does University People Finder do?

University People Finder gives you fast, filtered access to a curated dataset of faculty and staff from **top universities of the world**. Pick one or more institutions, add a free-text search and optional department or school filters, and the Actor returns matching records — names, emails, phones, offices, profile URLs, research areas, bios, and more — straight to your Apify dataset.

The dataset is continuously growing as we add more world-class institutions. You get the full Apify platform on top: scheduled runs, API access, integrations with Make, Zapier, Google Sheets, and webhook notifications when a run completes.

### What data does this university faculty extractor return?

Every record is structured and export-ready. Each faculty entry includes:

- **University** — the institution the person belongs to
- **Name** — full name, plus separate `first_name` and `last_name`
- **Title** — academic title (e.g. Professor, Associate Professor, Lecturer)
- **Titles** — list of all titles held by the person
- **Position** — primary position
- **Department** — academic department
- **Department (hierarchical)** — full department path where available
- **Academic groups** — affiliated centers, institutes, or working groups
- **School** — school or college within the university
- **Email** — direct email address
- **Phone** — direct phone number
- **Office** — physical office location
- **Profile URL** — link to the person's official faculty page
- **Website** — personal or lab website
- **Image URL** — official faculty photo
- **Research areas** — tagged research interests and focus areas
- **Bio summary** — short biography where available

> All records are structured and downloadable in **JSON, CSV, Excel, or HTML** — or accessible directly via the Apify API.

### Why use this university faculty contact database?

University and college websites publish faculty directories publicly, but extracting contacts manually is slow and doesn't scale. This Actor automates that process and gives you:

- **Structured data** — clean, consistent fields across every record from every institution
- **Filterable by university, department, or school** — target exactly who you need
- **Free-text search** across name, email, department, school, title, position, research areas, and bio
- **Email-only filter** — drop records without an email when you need contact info
- **Export to CSV, JSON, Excel, or connect to your CRM** via Apify integrations
- **Runs on demand or on a schedule** — keep your contact list fresh automatically
- **No coding required** — configure inputs and run directly from your browser

### Who uses university faculty contact data?

#### EdTech & education software companies
Reach professors and department heads who evaluate and adopt new tools for their classrooms, labs, and institutions. Faculty are the primary buyers — or the key influencers — for academic software, LMS platforms, and digital learning tools.

#### Academic publishers & textbook companies
Connect with professors who assign course materials and lecturers who review new titles. Build targeted outreach lists segmented by subject area or department.

#### Research & survey firms
Find domain experts for academic surveys, expert panels, or qualitative research interviews. Filter by department or research focus to reach the most relevant contacts.

#### B2B sales teams
Universities are large institutions with real procurement budgets. Reach decision-makers across departments for software, services, and equipment.

#### Conference organizers & event planners
Build speaker invitation lists for academic conferences, panels, and professional development events. Target by subject area, department, or institution.

#### Recruiters & talent teams
Identify academic professionals for industry advisory boards, research consulting roles, or direct-hire opportunities in the private sector.

#### Journalists & policy researchers
Quickly identify subject-matter experts across top universities for interviews, expert quotes, and background research.

### How to find professor emails and academic contacts

#### Step 1 — Configure your search

Set your filters in the Input form. **All fields are optional.** When you open the form, the **Universities** field is empty (which means "search all") and **Max results** is pre-filled to **100** so your first run stays small while you experiment.

| Input | Description |
|-------|-------------|
| **Universities** | One or more universities to search. **Leave empty to search every university in the dataset** (this is the default). Pick specific ones only when you want to narrow down. |
| **Search keyword** | Free-text search across name, email, department, school, title, position, research areas, and bio (e.g. "machine learning", "economics"). |
| **Departments** | Filter by department (e.g. Computer Science, Marketing, Biology). |
| **Schools** | Filter by school or college within the university (e.g. Business School, School of Medicine). |
| **Only show faculty with an email address** | Toggle on to drop records that don't have an email address. Useful for outreach lists. |
| **Max results** | Cap the number of records returned per run. Pre-filled to `100`. Set to `0` for no limit. If you clear the field, it falls back to `1000`. |

**Just click Start?** With the defaults you'll get up to 100 faculty records spread across every university in the dataset — a quick sample to see what the data looks like. Bump up **Max results** (or set it to `0`) when you're ready for a full export.

#### Step 2 — Run the Actor

Click **Start** and the Actor will return matching faculty records to your dataset.

#### Step 3 — Export and use

Download results as **CSV**, **JSON**, **Excel**, or **HTML** — or connect directly to tools like HubSpot, Salesforce, Airtable, or Google Sheets via Apify integrations, Zapier, Make, and n8n.

### Input

The Actor takes a single JSON object. All fields are optional.

```json
{
    "universities": ["Harvard", "MIT"],
    "query": "machine learning",
    "departments": [],
    "schools": ["Harvard Business School"],
    "hasEmail": true,
    "limit": 500
}
````

### Output

Each dataset item is one faculty record. Download as JSON, CSV, Excel, or HTML from the run page.

```json
{
    "id": 1,
    "university": "Harvard",
    "name": "Rawi Abdelal",
    "first_name": "Rawi",
    "last_name": "Abdelal",
    "title": null,
    "department": "Business, Government & International Economy",
    "school": "Harvard Business School",
    "email": null,
    "phone": null,
    "office": null,
    "profile_url": "https://www.hbs.edu/faculty/Pages/profile.aspx?facId=6628&click=byline",
    "website": null,
    "image_url": null,
    "research_areas": [],
    "bio_summary": null,
    "position": null,
    "academic_groups": [],
    "department_hierarchical": null,
    "titles": []
}
```

> Missing fields are returned as `null` (not empty strings). List fields like `research_areas`, `academic_groups`, and `titles` come back as empty arrays when no values are available.

### Data fields

| Field | Type | Description |
| --- | --- | --- |
| `id` | int | Internal row id (stable within a single dataset snapshot). |
| `university` | string | The university the person belongs to. |
| `name`, `first_name`, `last_name` | string | Full and split names. |
| `title`, `titles`, `position` | string / string\[] | Position titles (single, list, primary). |
| `department`, `department_hierarchical`, `school` | string | Organizational placement. |
| `academic_groups` | string\[] | Affiliated academic groups, centers, or institutes. |
| `email`, `phone`, `office` | string | Contact info (may be empty). |
| `profile_url`, `website`, `image_url` | string | Official faculty page, personal site, photo. |
| `research_areas` | string\[] | Tagged research interests and focus areas. |
| `bio_summary` | string | Short biography where available. |

Field completeness varies by university and by faculty member — some institutions publish more contact detail than others.

### Filter faculty by university, department, or school

This university faculty scraper is built for precision targeting. You can narrow your results by:

- **Institution** — pick one university or run across many at once
- **Academic department** — STEM, business, humanities, medical schools, law, engineering, and more
- **School or college** — target a specific school within a university
- **Free-text search** — match on title, name, research area, or any visible field
- **Email-only** — restrict to records that include an email address

### Export university faculty contacts to CSV or your CRM

All results are available in multiple export formats:

- **CSV** — ready to import into any email marketing or CRM platform
- **JSON** — for custom pipelines and integrations
- **Excel (XLSX)** — for manual review and segmentation
- **HTML** — for quick visual browsing
- **Apify Dataset API** — accessible programmatically for automated workflows

You can also connect this Actor to your stack using the [Apify API](https://docs.apify.com/api/v2) or native integrations with Zapier, Make (formerly Integromat), and n8n.

### Pricing & cost estimation

Runs are typically very fast — most queries finish in well under a minute. Cost scales with how many records you return, so use the **Max results** input while you're iterating on filters and remove the cap for full exports.

### Tips and advanced options

- **Narrow first, expand later.** Start with one university plus a search query to see what comes back, then loosen filters.
- **Use Max results for previews.** Set it to 50 while you're iterating on filters; remove it for the full export.
- **Combine with Apify integrations.** Schedule a recurring run and pipe the dataset to Google Sheets, Slack, HubSpot, or a webhook.
- **EdTech lead generation.** Filter by department (e.g. Computer Science or Business) and toggle Only with email, then export to CSV for your outreach sequence.

### Frequently asked questions

#### Is this data publicly available?

Yes. This Actor returns contact information that universities publish on their public-facing faculty directory pages. The data is intended for professional outreach and research purposes.

#### How fresh is the data?

The dataset is refreshed periodically. Schedule recurring runs in Apify to make sure your downstream lists stay current.

#### Can I pull data from multiple universities in one run?

Yes. Select multiple universities in the input — or leave the field empty to search across every university in the dataset.

#### Why are some fields empty?

Each university publishes a different subset of information. Email, phone, and office are particularly inconsistent. Use the **Only with email** toggle if you specifically need contact info.

#### What's the best way to use this for EdTech lead generation?

Filter by department (e.g. Computer Science or Business), turn on Only with email, then export to CSV for use in your email outreach sequence. Combine with school-level filters to build tightly segmented lists.

#### Which universities are covered?

The dataset covers top universities of the world and is continuously growing. Open the Universities dropdown in the Input form to see the current list.

#### Found a bug or want a university added?

Open an issue on the Actor's **Issues** tab — we actively expand coverage based on user requests.

# Actor input Schema

## `universities` (type: `array`):

Which universities to search. Leave empty to search every university in the dataset.

## `query` (type: `string`):

Find faculty whose name, email, department, school, title, research area, or bio contains this word or phrase. For example: "machine learning", "economics", or a person's last name. Leave blank to match everyone.

## `departments` (type: `array`):

Only return faculty in these departments. Type the exact department name (e.g. "Computer Science", "Marketing"). Add multiple to match any of them. Leave empty to skip this filter.

## `schools` (type: `array`):

Only return faculty in these schools or colleges (e.g. "Harvard Business School", "School of Medicine"). Add multiple to match any of them. Leave empty to skip this filter.

## `hasEmail` (type: `boolean`):

Turn this on if you only want records that include an email address. Useful when you're building an outreach or contact list.

## `limit` (type: `integer`):

How many faculty records to return at most. Set to 0 for no limit. Lower this while you're testing your filters; raise it for full exports.

## Actor input object example

```json
{
  "universities": [],
  "query": "",
  "departments": [],
  "schools": [],
  "hasEmail": false,
  "limit": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

Structured faculty and staff records matching your search filters.

# 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 = {
    "universities": [],
    "query": "",
    "limit": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/university-people-finder").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 = {
    "universities": [],
    "query": "",
    "limit": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("hgservices/university-people-finder").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 '{
  "universities": [],
  "query": "",
  "limit": 100
}' |
apify call hgservices/university-people-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=hgservices/university-people-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "University People Finder",
        "description": "Extract professor emails, faculty contacts, and academic data from top universities of the world. Get names, emails, phones, departments, research areas, and profile URLs as CSV, JSON, or Excel.",
        "version": "0.1",
        "x-build-id": "NdnEntL0fcOqhDcw9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~university-people-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-university-people-finder",
                "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/hgservices~university-people-finder/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-university-people-finder",
                "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/hgservices~university-people-finder/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-university-people-finder",
                "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": {
                    "universities": {
                        "title": "Universities",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which universities to search. Leave empty to search every university in the dataset.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Brown",
                                "Cornell",
                                "Harvard",
                                "MIT",
                                "Princeton",
                                "Stanford",
                                "UPenn",
                                "Yale"
                            ]
                        },
                        "default": []
                    },
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Find faculty whose name, email, department, school, title, research area, or bio contains this word or phrase. For example: \"machine learning\", \"economics\", or a person's last name. Leave blank to match everyone.",
                        "default": ""
                    },
                    "departments": {
                        "title": "Departments",
                        "type": "array",
                        "description": "Only return faculty in these departments. Type the exact department name (e.g. \"Computer Science\", \"Marketing\"). Add multiple to match any of them. Leave empty to skip this filter.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "schools": {
                        "title": "Schools",
                        "type": "array",
                        "description": "Only return faculty in these schools or colleges (e.g. \"Harvard Business School\", \"School of Medicine\"). Add multiple to match any of them. Leave empty to skip this filter.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "hasEmail": {
                        "title": "Only show faculty with an email address",
                        "type": "boolean",
                        "description": "Turn this on if you only want records that include an email address. Useful when you're building an outreach or contact list.",
                        "default": false
                    },
                    "limit": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many faculty records to return at most. Set to 0 for no limit. Lower this while you're testing your filters; raise it for full exports.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
