# GitHub Lead Signals + AI (Companies & Developers by Tech Stack) (`lizzyyy2/github-lead-signals-ai`) Actor

Find companies and developers using any technology on GitHub, enrich their public profiles, and turn them into AI-scored B2B sales leads with a buying-signal summary and a personalized outreach opener. Built-in AI, no API key.

- **URL**: https://apify.com/lizzyyy2/github-lead-signals-ai.md
- **Developed by:** [Lizzy](https://apify.com/lizzyyy2) (community)
- **Categories:** Lead generation, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 ai lead scoring & outreaches

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## GitHub Lead Signals + AI — Companies & Developers by Tech Stack

Find the **companies and developers who already use a technology** on GitHub and turn them into **AI-scored B2B sales leads**. Give it a technology or search term (e.g. `stripe connect`, `langchain`, `kubernetes operator`) and get back the GitHub accounts using it — enriched with their public profile **plus** an AI read of *why they're a fit*, a buying-intent signal, a sales angle, and a personalized outreach opener.

Built-in AI. **No OpenAI / OpenRouter API key required.** No GitHub token required.

---

### Why "who uses this tech" is a buying signal

What an account builds with tells you what it's in the market for:

- A company with **Stripe Connect** repos → building marketplaces/payments → needs payments tooling, fraud, reconciliation, monitoring.
- A developer shipping **LangChain / LLM** repos → an AI builder → needs vector DBs, eval tools, GPU/inference.
- An org with **Kubernetes operators** → running cloud-native infra → needs observability, security, cost tooling.

Most GitHub scrapers just dump repos. This actor reads GitHub's **public REST API** (no anti-bot pain), **dedupes to the account behind the repos** (your actual lead), enriches their profile, and adds the layer that matters: **what it means for you.**

| | Raw GitHub scrapers | **GitHub Lead Signals (AI)** |
|---|:---:|:---:|
| Repositories matching a tech | ✅ | ✅ |
| Deduped to the **company/developer** (the lead) | ❌ | ✅ |
| Public profile: company, email, site, location | ❌ | ✅ |
| AI fit score (0–100) | ❌ | ✅ |
| Buying-intent signal + sales angle | ❌ | ✅ |
| Personalized outreach opener | ❌ | ✅ |
| Works with **no API key** | — | ✅ |

---

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array (required) | Technologies or GitHub search strings (e.g. `stripe connect`, `langchain`, `topic:fintech language:go`, `react stars:>500`). Each is searched against repositories; the owners become your leads. |
| `language` | string | Keep only repos in this language (e.g. `TypeScript`, `Go`). Empty = any. |
| `minStars` | integer | Keep only repos with at least this many stars. Higher = more established. `0` = no filter. |
| `ownerType` | select | `any`, `organizations` (companies only), or `users` (individual developers only). |
| `maxLeads` | integer (1–1000) | How many unique leads to return in total. Default `50`. |
| `enrichProfiles` | boolean | Fetch each lead's public profile (company, email, website, location, Twitter, followers, bio). Default `true`. |
| `aiSignals` | boolean | Built-in AI fit score, intent signal, sales angle and personalized opener. Default `true`. |
| `offerDescription` | string | What you sell — the AI ties each lead's tech usage to your offer and writes a personalized opener. |
| `aiLanguage` | string | Language for AI text. Default `English`. |
| `proxyConfiguration` | object | Apify Proxy rotates IPs to stay under GitHub's rate limits. Keep the default. |

#### Example input

```json
{
  "searchQueries": ["stripe connect", "langchain"],
  "minStars": 50,
  "ownerType": "any",
  "maxLeads": 50,
  "enrichProfiles": true,
  "aiSignals": true,
  "offerDescription": "We sell a developer-focused API monitoring and observability platform.",
  "aiLanguage": "English"
}
````

***

### Output

One row per **unique lead** (company or developer):

```json
{
  "login": "stripe",
  "ownerType": "Organization",
  "profileUrl": "https://github.com/stripe",
  "company": null,
  "email": "support+github@stripe.com",
  "location": "San Francisco, CA",
  "followers": 3247,
  "matchedRepoCount": 3,
  "totalStars": 869,
  "languages": ["Swift", "TypeScript", "JavaScript"],
  "topRepos": [
    { "fullName": "stripe/stripe-node", "stars": 400, "language": "TypeScript" }
  ],
  "leadType": "Company",
  "techStack": ["TypeScript", "Node.js", "Stripe", "Stripe Connect"],
  "fitScore": 85,
  "intentSignal": "Repos focus on Stripe-powered payment platforms — strong need for reliable API monitoring.",
  "salesAngle": "Emphasize reliability of their Stripe integrations in high-transaction environments.",
  "personalizedOpener": "I noticed your work with Stripe Connect — ensuring those transactions run smoothly is exactly what we help with.",
  "bestContactChannel": "email",
  "aiAnalyzed": true
}
```

***

### How it works

1. Searches GitHub's **public REST API** for repositories matching each query (with your `language` / `minStars` filters).
2. **Dedupes by owner** — many repos can belong to one account; your lead is the account, with its top matching repos aggregated.
3. Optionally enriches each lead's **public profile** (company, email, website, location, Twitter, followers, bio).
4. Runs **one AI call per lead** to score fit (0–100), summarize the buying-intent signal, suggest a sales angle, and write a personalized opener tied to their real repos.
5. Saves one clean lead row per account.

IPs are rotated automatically via Apify Proxy to stay under GitHub's unauthenticated rate limits, so larger runs keep flowing.

***

### Tips

- Add an `offerDescription` to get openers and a fit score tailored to *your* product.
- Use `ownerType: "organizations"` for B2B company lists, or `"users"` to recruit / reach individual builders.
- Combine tech terms in `searchQueries` (e.g. `langchain`, `llamaindex`, `vector database`) to widen an ICP in one run.
- Raise `minStars` to focus on established, better-resourced accounts.

***

### FAQ

**Do I need a GitHub or AI API key?**
No. It uses GitHub's public REST API and Apify's built-in AI model — nothing to manage.

**Is `email` always present?**
Only when the account has published a public email on GitHub. Many do; many don't. You also get website, Twitter and location to reach the rest.

**Will I get blocked?**
No. It reads the public JSON API and rotates IPs via Apify Proxy to respect GitHub's rate limits.

**Why dedupe to the owner instead of one row per repo?**
Because your lead is the *company or developer*, not each repo. One clean row per account keeps your outreach list tidy — with the top matching repos and aggregate signal attached.

**Can I turn AI or enrichment off?**
Yes. Turn off `aiSignals` for raw leads, or `enrichProfiles` for just the GitHub accounts — both lower cost.

***

### Related Actors — build a full pipeline

This Actor is the **"find who uses the tech"** step. Pair it with the others to go from signal → enriched contact → outreach:

- **GitHub Lead Signals (this Actor)** finds accounts using your target tech → feed companies into **AI Lead Enricher** to pull site profile, emails and a cold-email opener.
- Combine with **Hiring Signals (AI)** to cross-reference who's *both* using your tech *and* hiring for it — the strongest possible buying signal.

> Workflow: **GitHub Lead Signals (tech intent)** → **AI Lead Enricher (contact + opener)** → your CRM / sequencer.

# Actor input Schema

## `searchQueries` (type: `array`):

What to look for on GitHub. Use a plain technology or keyword (e.g. `stripe`, `kubernetes operator`, `langchain`) or a full GitHub search qualifier string (e.g. `topic:fintech language:go`, `react stars:>500`). Each query is searched against repositories; the repo owners (companies & developers using that tech) become your leads.

## `language` (type: `string`):

Only keep repositories written in this language (e.g. TypeScript, Go, Python). Leave empty for any language.

## `minStars` (type: `integer`):

Only keep repositories with at least this many stars. Higher = more established companies. 0 = no filter.

## `ownerType` (type: `string`):

Keep only organizations (companies), only individual developers, or both.

## `maxLeads` (type: `integer`):

How many unique leads (companies/developers) to return in total across all queries. 1-1000.

## `enrichProfiles` (type: `boolean`):

Fetch each lead's full public GitHub profile: company, public email, website/blog, location, Twitter, follower count and bio. Recommended for usable sales leads.

## `aiSignals` (type: `boolean`):

Use built-in AI to score each lead's buying-intent fit, summarize what technology signal they show, suggest a sales angle and write a personalized outreach opener. No API key needed.

## `offerDescription` (type: `string`):

Briefly describe your product/service. The AI ties each lead's tech usage to your offer and writes a personalized opener. Leave empty for a generic angle.

## `aiLanguage` (type: `string`):

Language for AI-generated text (e.g. English, German, Turkish).

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

Apify Proxy is used to rotate IPs and stay under GitHub's unauthenticated rate limits. Keep the default unless you have a reason to change it.

## Actor input object example

```json
{
  "searchQueries": [
    "stripe connect",
    "langchain"
  ],
  "minStars": 0,
  "ownerType": "any",
  "maxLeads": 50,
  "enrichProfiles": true,
  "aiSignals": true,
  "aiLanguage": "English",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `leads` (type: `string`):

Unique companies/developers found on GitHub with profile + AI sales intelligence in the default dataset.

# 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 = {
    "searchQueries": [
        "stripe connect",
        "langchain"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lizzyyy2/github-lead-signals-ai").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 = { "searchQueries": [
        "stripe connect",
        "langchain",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lizzyyy2/github-lead-signals-ai").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 '{
  "searchQueries": [
    "stripe connect",
    "langchain"
  ]
}' |
apify call lizzyyy2/github-lead-signals-ai --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lizzyyy2/github-lead-signals-ai",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Lead Signals + AI (Companies & Developers by Tech Stack)",
        "description": "Find companies and developers using any technology on GitHub, enrich their public profiles, and turn them into AI-scored B2B sales leads with a buying-signal summary and a personalized outreach opener. Built-in AI, no API key.",
        "version": "0.1",
        "x-build-id": "xEFniBbJ8pizYEtcW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lizzyyy2~github-lead-signals-ai/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lizzyyy2-github-lead-signals-ai",
                "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/lizzyyy2~github-lead-signals-ai/runs": {
            "post": {
                "operationId": "runs-sync-lizzyyy2-github-lead-signals-ai",
                "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/lizzyyy2~github-lead-signals-ai/run-sync": {
            "post": {
                "operationId": "run-sync-lizzyyy2-github-lead-signals-ai",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Search queries / technologies",
                        "minItems": 1,
                        "type": "array",
                        "description": "What to look for on GitHub. Use a plain technology or keyword (e.g. `stripe`, `kubernetes operator`, `langchain`) or a full GitHub search qualifier string (e.g. `topic:fintech language:go`, `react stars:>500`). Each query is searched against repositories; the repo owners (companies & developers using that tech) become your leads.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Programming language (optional filter)",
                        "type": "string",
                        "description": "Only keep repositories written in this language (e.g. TypeScript, Go, Python). Leave empty for any language."
                    },
                    "minStars": {
                        "title": "Minimum stars",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep repositories with at least this many stars. Higher = more established companies. 0 = no filter.",
                        "default": 0
                    },
                    "ownerType": {
                        "title": "Lead type",
                        "enum": [
                            "any",
                            "organizations",
                            "users"
                        ],
                        "type": "string",
                        "description": "Keep only organizations (companies), only individual developers, or both.",
                        "default": "any"
                    },
                    "maxLeads": {
                        "title": "Max leads",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many unique leads (companies/developers) to return in total across all queries. 1-1000.",
                        "default": 50
                    },
                    "enrichProfiles": {
                        "title": "Enrich public profiles",
                        "type": "boolean",
                        "description": "Fetch each lead's full public GitHub profile: company, public email, website/blog, location, Twitter, follower count and bio. Recommended for usable sales leads.",
                        "default": true
                    },
                    "aiSignals": {
                        "title": "AI lead scoring & outreach (premium)",
                        "type": "boolean",
                        "description": "Use built-in AI to score each lead's buying-intent fit, summarize what technology signal they show, suggest a sales angle and write a personalized outreach opener. No API key needed.",
                        "default": true
                    },
                    "offerDescription": {
                        "title": "What you sell (for personalization)",
                        "type": "string",
                        "description": "Briefly describe your product/service. The AI ties each lead's tech usage to your offer and writes a personalized opener. Leave empty for a generic angle."
                    },
                    "aiLanguage": {
                        "title": "AI output language",
                        "type": "string",
                        "description": "Language for AI-generated text (e.g. English, German, Turkish).",
                        "default": "English"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is used to rotate IPs and stay under GitHub's unauthenticated rate limits. Keep the default unless you have a reason to change it.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```