# Daycare & Childcare License Leads Scraper (`devilscrapes/daycare-license-leads`) Actor

Scrape licensed daycare and childcare facility registries across 5 US states (NY, CT, CO, DE, TX) via official state open-data APIs. Get facility name, license number, capacity, address, phone, and status — clean B2B leads, ready to export.

- **URL**: https://apify.com/devilscrapes/daycare-license-leads.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Daycare & Childcare License Leads — Scrape US State Registries

**$4.00 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We run the gauntlet so your lead list lands clean._ 😈

Pull licensed daycare and childcare facility records from official US state open-data registries in one run. Five states, thousands of facilities, one structured dataset — name, address, phone, capacity, license number, and status, ready to pipe into your CRM or outreach tool.

</div>

---

### 🎯 What this scrapes

Every US state that issues childcare licenses maintains a public registry. Five of those registries are published as machine-readable open-data APIs: New York, Connecticut, Colorado, Delaware, and Texas. This Actor queries each selected state's official Socrata SODA endpoint, paginates through every record, normalises the columns into a single consistent schema, and delivers one clean dataset row per licensed facility.

The state portals handle pagination internally, apply their own schema quirks, and return data in varying column layouts. We handle all of that per-state detail for you — you get a uniform output regardless of which states you select.

### 🔥 What we handle for you

- 🛡️ **Browser fingerprint rotation** — `curl-cffi` impersonates real Chrome / Firefox / Safari TLS handshakes so state API gateways see a genuine browser, not a Python script.
- 🌐 **Residential proxy rotation** via Apify Proxy — fresh session and exit IP on every block or rate-limit response.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 503` — up to 5 attempts per page, `Retry-After` header honoured.
- 🧱 **Per-state active-only filtering** — NY and CT support server-side status filters; we apply them automatically when `activeOnly` is enabled, so you get live facilities without post-processing.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, JSON / CSV / Excel export straight from the Apify Console.
- 💰 **Pay-Per-Event pricing** — you only pay for results that hit your dataset. No data, no charge (beyond the small warm-up fee).

### 💡 Use cases

- **B2B sales to daycare owners** — pull every licensed daycare center in Texas with phone and address, then enrich with email via Clay or Apollo for a targeted outreach sequence.
- **Childcare service vendors** — playground equipment suppliers, catering companies, and educational software vendors can build state-level prospect lists in minutes.
- **Consulting / compliance** — regulatory consultants track capacity and status changes across state portfolios without scraping PDF tables by hand.
- **Real estate & site selection** — developers and municipalities map licensed childcare capacity by county to identify underserved areas.
- **Market research** — compare childcare supply across states, facility-type mix (family home vs. center), or average licensed capacity by city.
- **Insurance & financial services** — commercial insurers and lenders targeting childcare operators need addressable prospect lists at scale.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Select one or more states in the **States to scrape** field.
3. Toggle **Active facilities only** — enabled by default; disabling it returns expired and inactive licenses too.
4. Set **Max results** to cap the run size. Each state has tens of thousands of records; start small.
5. Click **Start**. Output streams into the run's dataset in real time.
6. Export from **Storage → Dataset** as JSON, CSV, or Excel — or pull via the Apify API into your pipeline.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `states` | `array` | no | `["NY"]` | One or more state codes: `NY`, `CT`, `CO`, `DE`, `TX`. |
| `activeOnly` | `boolean` | no | `true` | Filter to active/licensed facilities. Applied on the server for NY and CT; ignored for CO, DE, TX (no status column). |
| `maxResults` | `integer` | no | `100` | Maximum total records across all selected states. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": false}` | Proxy settings. Optional for low-volume runs against these open-data APIs. |

#### Example input

```json
{
  "states": ["NY", "TX"],
  "activeOnly": true,
  "maxResults": 500,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output

Every row is one licensed childcare or daycare facility. Export as JSON, CSV, or Excel from the Apify Console.

| Field | Type | Notes |
|---|---|---|
| `state` | `string` | Two-letter state code — e.g. `NY`, `TX`. |
| `facility_name` | `string` | Name of the childcare facility or daycare center. |
| `licensee_name` | `string \| null` | Legal name of the licensee or governing body. |
| `license_number` | `string \| null` | State-issued license or provider ID number. |
| `facility_type` | `string \| null` | Program type — e.g. `Day Care Center`, `Family Day Care Home`. |
| `capacity` | `integer \| string \| null` | Licensed capacity in number of children. |
| `address` | `string \| null` | Street address. |
| `city` | `string \| null` | City. |
| `county` | `string \| null` | County (NY, CO, DE, TX; null for CT). |
| `zip` | `string \| null` | ZIP / postal code. |
| `phone` | `string \| null` | Contact phone number (NY, CT, DE, TX; null for CO). |
| `status` | `string \| null` | License status — e.g. `Active`, `Expired`. Null for CO, DE, TX. |
| `email` | `string \| null` | Contact email (TX only). |
| `website` | `string \| null` | Facility website URL (TX only). |
| `source_url` | `string` | Socrata API endpoint this record came from. |
| `scraped_at` | `string` | ISO-8601 UTC timestamp of when this row was recorded. |

#### Example output

```json
{
  "state": "TX",
  "facility_name": "Sunshine Learning Center",
  "licensee_name": "Maria Lopez",
  "license_number": "1234567",
  "facility_type": "Licensed Child Care Center",
  "capacity": 72,
  "address": "4500 Oak Drive",
  "city": "Austin",
  "county": "Travis",
  "zip": "78701",
  "phone": "512-555-0198",
  "status": "Licensed",
  "email": "director@sunshinelearning.example",
  "website": "https://sunshinelearning.example",
  "source_url": "https://data.texas.gov/resource/bc5r-88dy.json",
  "scraped_at": "2026-06-07T09:00:00+00:00"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result` | $0.004 | Per facility record pushed to the dataset |

Example: 1 000 results at the rates above ≈ **$4.00**. No subscription, no minimum — Apify gives every new account $5 of free credit, so your first run costs nothing.

### 🚧 Limitations

- **Five states only.** NY, CT, CO, DE, and TX are currently supported. Other states publish their registries in different formats (PDFs, proprietary portals, bulk downloads); adding each requires custom integration work.
- **Status filtering varies by state.** CO, DE, and TX datasets don't expose a status column, so `activeOnly` has no effect on those states — all records are returned.
- **TX email and website coverage is partial.** Texas includes email and website fields, but not every operator fills them in the public registry.
- **Data freshness depends on the state.** Each state updates its open-data portal on its own schedule — typically daily to weekly. The `scraped_at` field tells you when we fetched; the underlying source may lag behind actual license changes.
- **No photos, inspection reports, or violation histories.** This Actor returns the registration-level metadata only. Inspection and complaint data live in separate datasets.

### ❓ FAQ

**Is there a national childcare license database I can query?**

No unified federal registry exists. Childcare licensing is administered state by state. This Actor consolidates five of the most accessible state registries into one output schema.

**Can I get a licensed daycare list by city or county?**

Yes — filter post-export by the `city` or `county` column. Most states include county. Alternatively, run a single-state query and filter in your spreadsheet or CRM import.

**How do I build a daycare email list?**

Texas is the only state in this dataset that publishes email addresses in the public registry. For other states, enrich the `facility_name` + `address` output through a tool like Clay or Apollo after export.

**Why are some fields null?**

Not every state publishes every field. CO has no phone column; DE and TX have no status column. We surface `null` rather than fabricate. The `source_url` field tells you which registry each record came from.

**How many records are in each state?**

Approximate counts at time of writing: NY ~50 000, CT ~4 000, CO ~6 000, DE ~1 200, TX ~30 000. Counts change as licenses are issued and expire.

**Can I schedule this to run weekly?**

Yes — use **Apify Schedules** to trigger a run on a cadence. The `scraped_at` field and the `license_number` make deduplication straightforward for delta workflows.

**Does this scrape anything I shouldn't be using?**

All data comes from official state government open-data portals published for public access. No login, no scraping private pages, no personal data beyond what the state publishes in the licensing registry.

### 💬 Your feedback

Spotted a bug, need a new state added, or want a field we're not capturing? Open an issue on the Actor's **Issues** tab in the Apify Console — we read every report and ship fixes weekly.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `states` (type: `array`):

US state codes to scrape. Each maps to that state's official Socrata childcare licensing registry. Supported: NY, CT, CO, DE, TX.

## `activeOnly` (type: `boolean`):

When enabled, applies a status filter to return only currently active/licensed facilities. Supported for NY and CT; CO, DE, and TX datasets do not expose a status field.

## `maxResults` (type: `integer`):

Maximum total number of facility records to return across all selected states.

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

Apify Proxy settings. These are plain open-data JSON APIs; proxy is optional for low-volume runs.

## Actor input object example

```json
{
  "states": [
    "NY"
  ],
  "activeOnly": true,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "states": [
        "NY"
    ],
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/daycare-license-leads").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 = {
    "states": ["NY"],
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/daycare-license-leads").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 '{
  "states": [
    "NY"
  ],
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call devilscrapes/daycare-license-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Daycare & Childcare License Leads Scraper",
        "description": "Scrape licensed daycare and childcare facility registries across 5 US states (NY, CT, CO, DE, TX) via official state open-data APIs. Get facility name, license number, capacity, address, phone, and status — clean B2B leads, ready to export.",
        "version": "0.1",
        "x-build-id": "hLQI9Sc10cg90HzfS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~daycare-license-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-daycare-license-leads",
                "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/devilscrapes~daycare-license-leads/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-daycare-license-leads",
                "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/devilscrapes~daycare-license-leads/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-daycare-license-leads",
                "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": {
                    "states": {
                        "title": "States to scrape",
                        "type": "array",
                        "description": "US state codes to scrape. Each maps to that state's official Socrata childcare licensing registry. Supported: NY, CT, CO, DE, TX.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "NY",
                                "CT",
                                "CO",
                                "DE",
                                "TX"
                            ],
                            "enumTitles": [
                                "New York (NY)",
                                "Connecticut (CT)",
                                "Colorado (CO)",
                                "Delaware (DE)",
                                "Texas (TX)"
                            ]
                        },
                        "default": [
                            "NY"
                        ]
                    },
                    "activeOnly": {
                        "title": "Active facilities only",
                        "type": "boolean",
                        "description": "When enabled, applies a status filter to return only currently active/licensed facilities. Supported for NY and CT; CO, DE, and TX datasets do not expose a status field.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum total number of facility records to return across all selected states.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. These are plain open-data JSON APIs; proxy is optional for low-volume runs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
