# Hiring Signal Tracker - Hedge Fund Alt Data (`wiry_kingdom/hiring-signal-tracker`) Actor

Track company hiring signals: total openings, role mix, seniority, locations, remote ratio. Auto-detects Greenhouse, Lever, Ashby ATS. For hedge funds, quant traders, competitive intel, HR tech.

- **URL**: https://apify.com/wiry\_kingdom/hiring-signal-tracker.md
- **Developed by:** [Mohieldin Mohamed](https://apify.com/wiry_kingdom) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Hiring Signal Tracker — Hedge Fund Alternative Data

**Turn any company's career page into a structured hiring signal. Built for hedge funds, quant traders, and competitive intel teams that need to predict company growth before earnings.**

This actor tracks job posting volume and composition across companies, returning structured signals (total openings, role mix, seniority distribution, geographic spread, remote percentage, recent additions) that hedge funds use as a leading indicator of company health.

### What does Hiring Signal Tracker do?

You give it a list of companies and their careers page URLs. It auto-detects which ATS (applicant tracking system) each company uses — Greenhouse, Lever, Ashby, Workday, Rippling — and pulls the full job board via the official ATS API where possible. For companies with no recognizable ATS it falls back to generic HTML scraping.

For each company it returns:
- **Total open positions** (the headline signal)
- **Department mix**: engineering, sales, marketing, operations, design, data, product, customer success — as both counts and percentages
- **Seniority mix**: intern / junior / mid / senior / staff / principal / director / VP / C-level
- **Top locations** (top 10 cities/regions by job count)
- **Remote job count** (and percentage)
- **New jobs in the last 7 days** (delta tracking signal)
- **Sample titles** (first 10 job titles for spot-checking)

### Why use Hiring Signal Tracker?

The alternative data market is **$17 billion by 2027**. **78% of hedge funds now incorporate alternative data into their strategies** (Nasdaq State of Alternative Data 2025). Job posting trends are one of the most validated alt data signals — they predict revenue growth, M&A activity, and strategic pivots months ahead of earnings calls.

**Hedge funds and quant traders** use this to:
- Predict revenue growth (sales-team hiring → revenue growth in 2 quarters)
- Detect strategic pivots (engineering ratio jumping → new product line)
- Spot cost cuts before they hit earnings (hiring freeze → margin compression)
- Geographic expansion signals (new city in top locations → new market entry)
- M&A integration tracking (post-merger hiring patterns)

**Competitive intel teams** use this to:
- Track competitor org growth
- Identify which functions a competitor is investing in
- Predict competitive product launches based on engineering hiring spikes

**HR / recruiting tech vendors** use this to:
- Monitor industry hiring trends
- Build customer-facing competitor benchmarks
- Identify high-growth target accounts

**Job board aggregators** use this to:
- Source job listings at scale
- Detect new postings within 24h of being published

### How to use

1. Click **Try for free** (or **Start**)
2. Paste the JSON list of companies into **Companies** (just `name` + `careersUrl` for each)
3. Click **Start**
4. Download as JSON, CSV, HTML, or Excel — or schedule daily runs

### Input

```json
{
    "companies": [
        { "name": "Stripe", "careersUrl": "https://stripe.com/jobs", "ats": "autodetect" },
        { "name": "Anthropic", "careersUrl": "https://www.anthropic.com/careers", "ats": "autodetect" },
        { "name": "Notion", "careersUrl": "https://www.notion.so/careers", "ats": "autodetect" }
    ],
    "classifyRoles": true,
    "extractLocations": true,
    "extractSeniority": true
}
````

- **companies** — array of `{ name, careersUrl, ats }` objects (`ats` can be `autodetect` or one of `greenhouse | lever | ashby | workday | rippling`)
- **classifyRoles** — auto-classify into departments (default: yes)
- **extractLocations** — aggregate by city/region (default: yes)
- **extractSeniority** — classify into intern/junior/mid/senior/etc. (default: yes)

### Output

```json
{
    "company": "Stripe",
    "ats": "greenhouse",
    "careersUrl": "https://stripe.com/jobs",
    "totalJobs": 487,
    "departments": {
        "engineering": 195,
        "sales": 64,
        "marketing": 32,
        "operations": 58,
        "design": 28,
        "data": 41,
        "product": 22,
        "customer": 47
    },
    "seniorityMix": {
        "junior": 12,
        "mid": 215,
        "senior": 178,
        "staff": 52,
        "principal": 18,
        "director": 8,
        "vp": 4
    },
    "topLocations": [
        "Remote (124)",
        "San Francisco (98)",
        "Dublin (72)",
        "London (54)",
        "New York (48)",
        "Toronto (32)",
        "Singapore (28)",
        "Chicago (18)",
        "Tokyo (12)",
        "Berlin (10)"
    ],
    "remoteJobs": 124,
    "engineeringPercent": 40,
    "salesPercent": 13,
    "newJobs": 47,
    "snapshotAt": "2026-04-15T20:00:00.000Z",
    "sampleTitles": [
        "Staff Software Engineer, Payments",
        "Senior Account Executive, Enterprise",
        "Engineering Manager, Treasury",
        "Product Designer, Identity",
        "Data Scientist, Risk"
    ]
}
```

### Data table

| Field | Type | Description |
|-------|------|-------------|
| `company` | string | Company name as you provided it |
| `ats` | string | Detected ATS (greenhouse / lever / ashby / workday / generic) |
| `careersUrl` | string | The URL crawled |
| `totalJobs` | number | Total open positions |
| `departments` | object | Job counts by department |
| `seniorityMix` | object | Job counts by seniority level |
| `topLocations` | array | Top 10 cities by job count, formatted as `"City (count)"` |
| `remoteJobs` | number | Number of remote jobs |
| `engineeringPercent` | number | Engineering jobs as % of total |
| `salesPercent` | number | Sales jobs as % of total |
| `newJobs` | number | Jobs posted in the last 7 days (only available for ATS-backed companies) |
| `snapshotAt` | string | ISO timestamp |
| `sampleTitles` | array | First 10 job titles for spot-checking |

### Pricing

This actor uses **pay-per-event** pricing — perfect for tracking many companies at once:

- **Actor start**: $0.05 per run
- **Per company tracked**: $0.10 per company

**Example costs:**

- 1 company snapshot → $0.15
- Daily snapshot of 50 portfolio companies → ~$5/day = $150/month
- Weekly snapshot of the S\&P 500 → ~$50/week = $200/month
- Quarterly snapshot of 1,000 private companies for diligence → ~$100/quarter

Compare to Revelio Labs (~$15k/year base), Thinknum (~$50k/year), or LinkUp Data (~$80k/year). For most use cases this actor is dramatically cheaper.

Free Apify tier members get $5/month in platform credits, which covers ~50 company snapshots per month.

### Tips and advanced options

- **Schedule daily runs** to build a hiring time series — diff the daily snapshots downstream to detect changes
- **Track competitors quarterly** for competitive intel reports
- **Combine with SEC EDGAR Filing Monitor** to correlate hiring spikes with material disclosures
- **Pipe into a quant model** to test hiring signal as an alpha factor
- **Use ATS-specific input** (`"ats": "greenhouse"`) to skip auto-detection and save 1 HTTP request per company

### Supported ATS systems

| ATS | API | Coverage |
|-----|-----|----------|
| **Greenhouse** | `boards-api.greenhouse.io` (official, free) | Full structured data |
| **Lever** | `api.lever.co` (official, free) | Full structured data |
| **Ashby** | `api.ashbyhq.com/posting-api` (official) | Full structured data |
| **Workday** | (HTML scraping only) | Title + location |
| **Rippling** | (HTML scraping only) | Title + location |
| **Generic HTML** | (heuristic scraping) | Job titles, basic counts |

### FAQ and support

**Is the data real-time?** Greenhouse, Lever, and Ashby APIs return data within minutes of jobs being posted/closed. Generic HTML pages are eventually consistent.

**What about LinkedIn jobs?** LinkedIn aggressively blocks scrapers and our actor does not target their site. For LinkedIn-specific data, use a dedicated LinkedIn jobs scraper.

**Is this legal?** All ATS APIs we use (Greenhouse, Lever, Ashby) are publicly documented and free for commercial use. The companies themselves publish job listings to be discovered. We respect rate limits and identify ourselves with a clear User-Agent.

**Can I track private companies?** Yes — many private companies use Greenhouse / Lever / Ashby and have publicly browsable job boards. The actor handles them just as well as public companies.

**Found a bug?** Open an issue on the Issues tab.

# Actor input Schema

## `companies` (type: `array`):

Array of objects: { name, careersUrl, ats } where ats is one of 'greenhouse', 'lever', 'workday', 'ashby', 'rippling', 'autodetect'.

## `classifyRoles` (type: `boolean`):

Auto-classify jobs into engineering / sales / marketing / ops / design / data / product departments using title heuristics.

## `extractLocations` (type: `boolean`):

Pull location info from each job posting and aggregate by city/region.

## `extractSeniority` (type: `boolean`):

Detect seniority level (intern/junior/mid/senior/staff/principal/director/vp) from job titles.

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

Optional Apify Proxy. Most career pages and ATS APIs are friendly, but enable proxy if you hit rate limits.

## Actor input object example

```json
{
  "companies": [
    {
      "name": "Stripe",
      "careersUrl": "https://stripe.com/jobs",
      "ats": "autodetect"
    },
    {
      "name": "Anthropic",
      "careersUrl": "https://www.anthropic.com/careers",
      "ats": "autodetect"
    }
  ],
  "classifyRoles": true,
  "extractLocations": true,
  "extractSeniority": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "companies": [
        {
            "name": "Stripe",
            "careersUrl": "https://stripe.com/jobs",
            "ats": "autodetect"
        },
        {
            "name": "Anthropic",
            "careersUrl": "https://www.anthropic.com/careers",
            "ats": "autodetect"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("wiry_kingdom/hiring-signal-tracker").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 = { "companies": [
        {
            "name": "Stripe",
            "careersUrl": "https://stripe.com/jobs",
            "ats": "autodetect",
        },
        {
            "name": "Anthropic",
            "careersUrl": "https://www.anthropic.com/careers",
            "ats": "autodetect",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("wiry_kingdom/hiring-signal-tracker").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 '{
  "companies": [
    {
      "name": "Stripe",
      "careersUrl": "https://stripe.com/jobs",
      "ats": "autodetect"
    },
    {
      "name": "Anthropic",
      "careersUrl": "https://www.anthropic.com/careers",
      "ats": "autodetect"
    }
  ]
}' |
apify call wiry_kingdom/hiring-signal-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hiring Signal Tracker - Hedge Fund Alt Data",
        "description": "Track company hiring signals: total openings, role mix, seniority, locations, remote ratio. Auto-detects Greenhouse, Lever, Ashby ATS. For hedge funds, quant traders, competitive intel, HR tech.",
        "version": "0.1",
        "x-build-id": "DbzbJanXP2Pdmv12L"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/wiry_kingdom~hiring-signal-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-wiry_kingdom-hiring-signal-tracker",
                "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/wiry_kingdom~hiring-signal-tracker/runs": {
            "post": {
                "operationId": "runs-sync-wiry_kingdom-hiring-signal-tracker",
                "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/wiry_kingdom~hiring-signal-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-wiry_kingdom-hiring-signal-tracker",
                "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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies to track",
                        "type": "array",
                        "description": "Array of objects: { name, careersUrl, ats } where ats is one of 'greenhouse', 'lever', 'workday', 'ashby', 'rippling', 'autodetect'.",
                        "default": [
                            {
                                "name": "Stripe",
                                "careersUrl": "https://stripe.com/jobs",
                                "ats": "autodetect"
                            },
                            {
                                "name": "Anthropic",
                                "careersUrl": "https://www.anthropic.com/careers",
                                "ats": "autodetect"
                            }
                        ]
                    },
                    "classifyRoles": {
                        "title": "Classify roles into departments",
                        "type": "boolean",
                        "description": "Auto-classify jobs into engineering / sales / marketing / ops / design / data / product departments using title heuristics.",
                        "default": true
                    },
                    "extractLocations": {
                        "title": "Extract job locations",
                        "type": "boolean",
                        "description": "Pull location info from each job posting and aggregate by city/region.",
                        "default": true
                    },
                    "extractSeniority": {
                        "title": "Classify seniority",
                        "type": "boolean",
                        "description": "Detect seniority level (intern/junior/mid/senior/staff/principal/director/vp) from job titles.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy. Most career pages and ATS APIs are friendly, but enable proxy if you hit rate limits.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
