# Guru.com Scraper | Freelance Jobs and Profiles (`parseforge/guru-com-scraper`) Actor

Scrape freelance jobs and freelancer profiles from Guru.com with title, budget, skills, location, ratings, reviews, project descriptions, and apply links. Source talent, monitor gig pricing, generate leads, and build freelance market intelligence for staffing and recruiting.

- **URL**: https://apify.com/parseforge/guru-com-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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

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

## 💼 Guru.com Scraper

> 🚀 **Export Guru.com freelancer profiles in seconds.** Search by skill or keyword and download names, rates, ratings, job counts, earnings, and profile links in one structured dataset.

> 🕒 **Last updated:** 2026-05-22 · **📊 12 fields** per record · **Up to 1,000,000 profiles** · **Global freelancer coverage**

The Guru.com Scraper extracts freelancer profile data from Guru.com - one of the largest freelance platforms in the world - using browser-like HTML scraping with residential US proxies. Each record includes the freelancer's name, professional title, listed skills, hourly rate, feedback rating, number of reviews, jobs completed, annual earnings, and a direct link to their profile.

Guru.com hosts hundreds of thousands of verified freelancers across every professional category - from web development and design to legal, finance, writing, and engineering. This scraper lets you access that talent pool in bulk without manual browsing.

### Target Audience

| Who | Why |
|-----|-----|
| Recruitment and HR teams | Source and vet freelancers at scale without manual searching |
| Procurement managers | Compare freelancer rates and track across categories |
| Market researchers | Analyze freelance market pricing and talent availability |
| Startups and agencies | Build shortlists of candidates for specific skill sets |
| Competitor intelligence teams | Understand talent supply and pricing in specific domains |

### 📋 What the Guru.com Scraper does

- Searches Guru.com's freelancer directory by keyword or skill
- Scrapes listing pages and then follows each profile link to get full detail
- Collects jobs completed from the profile's transaction history
- Fetches review count from the profile's dedicated reviews page
- Paginates automatically across up to 500 pages of results
- Uses residential US proxies with Chrome-like headers to avoid blocking

> 💡 **Why it matters:** Guru.com has no public API. This actor is the only way to systematically collect freelancer data at scale - enabling talent sourcing, rate benchmarking, and market analysis that would otherwise require days of manual work.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `query` | string | *(empty - all freelancers)* | Search keyword or skill (e.g. "react developer", "logo design") |
| `maxItems` | integer | `10` | Maximum number of profiles to collect (free: 10, paid: up to 1,000,000) |

**Example 1 - Search for Python developers:**
```json
{
  "query": "python developer",
  "maxItems": 200
}
````

**Example 2 - Search for graphic designers:**

```json
{
  "query": "logo design",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Each profile requires two additional HTTP requests (for job count and review count), so large runs take longer than listing-only scrapers. Leave `query` empty to browse all freelancers. Free users are limited to 10 profiles per run.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | Profile photo URL |
| 👤 `name` | string | Freelancer's display name |
| 📝 `title` | string | Professional service title listed on Guru |
| 🛠️ `skills` | array | List of skill tags from the profile |
| 💰 `hourlyRate` | number | Listed hourly rate |
| 💱 `currency` | string | Currency code (USD, GBP, EUR) |
| ⭐ `rating` | number | Positive feedback percentage (0-100) |
| 💬 `reviewCount` | number | Total number of client reviews |
| ✅ `jobsCompleted` | number | Number of transactions completed |
| 📈 `earnings` | string | Annual earnings indicator (e.g. "50000/yr") |
| 📍 `location` | string | City, state, country |
| 🔗 `profileUrl` | string | Direct link to the Guru.com profile |
| 🕒 `scrapedAt` | string | ISO timestamp of when the record was collected |

**Sample record:**

```json
{
  "imageUrl": "https://www.guru.com/profiles/avatars/abc123.jpg",
  "name": "Alex K.",
  "title": "Full-Stack React & Node.js Developer",
  "skills": ["React", "Node.js", "TypeScript", "PostgreSQL", "AWS"],
  "hourlyRate": 75,
  "currency": "USD",
  "rating": 99.5,
  "reviewCount": 143,
  "jobsCompleted": 187,
  "earnings": "120000/yr",
  "location": "Austin, TX, United States",
  "profileUrl": "https://www.guru.com/freelancers/alex-k/",
  "scrapedAt": "2026-05-22T09:15:00.000Z"
}
```

### ✨ Why choose this Actor

- **Three-level data extraction** - listing, profile detail, and reviews page for each freelancer
- **Skills array** - all listed skills extracted as a clean JSON array, not a comma string
- **Rate parsing** - handles USD, GBP, and EUR hourly rates automatically
- **Residential proxies built in** - no configuration needed, reliable access at scale
- **Deduplication** - each profile URL is only visited once even across multiple listing pages
- **Pay-per-item pricing** - only pay for profiles you actually collect

### 📈 How it compares to alternatives

| Feature | ParseForge Guru Scraper | Manual browsing | LinkedIn scraping |
|---------|------------------------|-----------------|------------------|
| Bulk export | Yes, up to 1M | No | Difficult, ToS risk |
| Hourly rates | Yes | Yes | Rarely public |
| Jobs completed | Yes | Yes | No |
| Reviews count | Yes | Yes | Not applicable |
| Earnings indicator | Yes | Yes | No |
| Skills array | Yes | Yes | Sometimes |
| Free tier | 10 profiles | Unlimited (slow) | N/A |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the Guru.com Scraper actor page and click **Try for free**
3. Enter a keyword (e.g. `mobile app developer`, `content writer`, `data analyst`)
4. Set `maxItems` to the number of profiles you need
5. Click **Start** and wait for collection to complete
6. Download your dataset as CSV, JSON, Excel, or connect via API

### 💼 Business use cases

#### Talent Sourcing and Recruitment

Build a shortlist of candidates for a specific skill set and budget. Filter the exported data by hourly rate, rating, and jobs completed to identify the most experienced and affordable candidates.

#### Freelance Rate Benchmarking

HR teams and procurement managers can collect hundreds of rate cards for a given skill to establish fair market pricing before posting a job or negotiating with existing contractors.

#### Market Intelligence

Analyze the supply of freelancers in specific skills or geographies - useful for workforce planning, training product development, or understanding where talent concentrations exist.

#### Platform and Product Research

Companies building freelance platforms or tools can use this data to understand Guru.com's talent pool composition, pricing tiers, and geographic distribution.

### 🔌 Automating Guru.com Scraper

- **Make (formerly Integromat)** - Schedule weekly runs to refresh your freelancer database in Airtable or Notion
- **Zapier** - Automatically add new profiles matching your criteria to a CRM or recruitment tracker
- **Google Sheets** - Sync exported data directly to a shared sheet for team review and filtering
- **REST API** - Trigger runs programmatically from your ATS or internal hiring tools

### 🌟 Beyond business use cases

#### Academic Research

Researchers studying the gig economy can collect systematic data on freelance pricing, skill demand, and geographic distribution of remote workers.

#### Journalism and Reporting

Journalists covering labor market trends can analyze how freelance rates have shifted across different professional categories.

#### Freelancer Community Tools

Build salary and rate comparison tools for freelance communities using real market data rather than self-reported surveys.

#### Portfolio Analysis

Aspiring freelancers can benchmark their own rates and profile positioning against top-rated competitors in their niche.

### 🤖 Ask an AI assistant about this scraper

Not sure how to work with your data? Ask an AI:

> "I have JSON data from the Guru.com Scraper with fields like skills, hourlyRate, rating, and jobsCompleted. How do I find the top 20 React developers with a rating above 95% and more than 50 jobs completed, sorted by hourly rate?"

The structured output is designed to be immediately queryable with any data tool or AI assistant.

### ❓ Frequently Asked Questions

**Does this require a Guru.com account?**
No. All data is scraped from publicly visible profile pages. No login is required.

**What does the `rating` field represent?**
It is the positive feedback percentage shown on Guru.com (e.g. 99.2 means 99.2% positive feedback from clients).

**What is the `earnings` field?**
An annual earnings indicator extracted from the profile (e.g. "50000/yr"). This is a Guru.com-defined band, not an exact income figure.

**Why are `reviewCount` and `jobsCompleted` sometimes null?**
Some profiles have no reviews yet, or the profile/reviews page was temporarily unavailable during the run.

**Can I search by category instead of keyword?**
The `query` field maps to Guru.com's site-wide search. For category-level browsing, leave `query` empty.

**How many profiles can I collect?**
Free users get 10. Paid users can collect up to 1,000,000 profiles across up to 500 pages of results.

**How long does a run take?**
Each profile requires 2 additional page fetches. For 100 profiles, expect approximately 5-10 minutes depending on proxy latency.

**Are freelancers' real names shown?**
Only the display name or username as shown publicly on Guru.com.

**Does it collect portfolio items or work samples?**
Not currently. The scraper focuses on profile metadata: rates, skills, ratings, and job history.

**Is the data updated in real time?**
Yes. Every run fetches live data directly from Guru.com. There is no caching.

**Can I filter by country?**
Not at the input level. The `location` field in the output includes country information you can filter on after export.

**What if a profile page is unavailable?**
The job count and review count for that profile will be `null`. The rest of the profile data from the listing page is still included.

### 🔌 Integrate with any app

Export your dataset to:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable

**Databases:** PostgreSQL, MySQL, MongoDB, Supabase

**CRM and HR:** HubSpot, Salesforce, Greenhouse, Lever

**Automation:** Make, Zapier, n8n, Pipedream

**Analytics:** Tableau, Power BI, Metabase, Google Looker Studio

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Upwork Scraper](https://apify.com/parseforge) | Extract freelancer profiles and job postings from Upwork |
| [Fiverr Scraper](https://apify.com/parseforge) | Scrape Fiverr gig listings and seller data |
| [LinkedIn Jobs Scraper](https://apify.com/parseforge) | Collect job postings from LinkedIn by keyword and location |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 50+ ready-to-use data extractors covering freelance platforms, job boards, marketplaces, and more.

***

**Disclaimer:** This actor is an independent tool not affiliated with, endorsed by, or connected to Guru.com Inc. It accesses only publicly available profile data. Use responsibly and in accordance with Guru.com's Terms of Service. ParseForge is not responsible for how collected data is used.

# Actor input Schema

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

Search keyword to find freelancers (e.g. 'web developer', 'graphic designer', 'python'). Leave empty to browse all freelancers.

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

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

## Actor input object example

```json
{
  "query": "web developer",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "web developer",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/guru-com-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 = {
    "query": "web developer",
    "maxItems": 10,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Guru.com Scraper | Freelance Jobs and Profiles",
        "description": "Scrape freelance jobs and freelancer profiles from Guru.com with title, budget, skills, location, ratings, reviews, project descriptions, and apply links. Source talent, monitor gig pricing, generate leads, and build freelance market intelligence for staffing and recruiting.",
        "version": "0.1",
        "x-build-id": "8dZhQyb8lkaOMsAXA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~guru-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-guru-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~guru-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-guru-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~guru-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-guru-com-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Search keyword to find freelancers (e.g. 'web developer', 'graphic designer', 'python'). Leave empty to browse all freelancers."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```