# Multi-State Childcare Licensing + Inspections (`civicdataforge/multistate-childcare-licensing`) Actor

Licensed childcare facilities across NY, NJ, CO, CT and DE in one unified schema — name, type, address, county, capacity, license status — plus the compliance record where the state publishes it: inspection counts (CT, DE) and cited-deficiency detail (DE).

- **URL**: https://apify.com/civicdataforge/multistate-childcare-licensing.md
- **Developed by:** [Bryan](https://apify.com/civicdataforge) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 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

## Multi-State Childcare Licensing + Inspections

Every licensed childcare facility across **five states — New York, New Jersey, Colorado, Connecticut
and Delaware — in ONE unified schema.** Daycares, licensed centers, family child-care homes: name,
type, address, county, capacity, license status. And the field nobody else normalizes across states:
**the compliance record.** Where the state publishes it, each facility carries its inspection count and,
for Delaware, cited-deficiency counts with the top regulations cited.

Sister actor to our single-state [Texas Childcare Licensing + Violations] — same buyers, wider map.

### Coverage (all endpoints data-layer verified 2026-07-12)

| State | Facilities | Inspection data | Deficiency data |
|---|---|---|---|
| **NY** New York | 16,798 | — | — |
| **NJ** New Jersey | 4,163 | — | — |
| **CO** Colorado | 4,508 | — | — |
| **CT** Connecticut | 16,188 | inspection_count (97,283-row feed, join verified 107/107) | — |
| **DE** Delaware | 1,249 | inspection_count (visits) | deficiency_count + top regulations cited (11,853-row feed, join verified 165/165) |

### Unified record

```json
{
  "state": "DE",
  "name": "YMCA Of Delaware / Central Branch",
  "type": "Licensed Early Care and Education",
  "address": "11 W 11TH ST",
  "city": "WILMINGTON", "county": "New Castle", "state_code": "DE", "zip": "19801",
  "license_number": "27399", "license_status": "Licensed",
  "capacity": 120, "issue_date": null, "expiration_date": null,
  "inspection_count": 6,
  "deficiency_count": 14,
  "deficiency_details": { "non_compliance_count": 9, "top_regulations_cited": [ { "desc": "Ratios, Group Size, and Supervision", "count": 3 } ] },
  "raw": { "...": "full original source row" }
}
````

Compliance fields are **null, never fabricated**, for states/facilities where the source publishes no
inspection data. NY suppresses the street address for 655 family day-care homes (`address_omitted`) —
those are honest nulls too.

### Who uses this

- **Childcare insurers** — underwrite across a multi-state book on actual deficiency history, not applications.
- **Childcare SaaS & marketplaces** — market sizing and lead lists spanning states in one shape.
- **Franchise & site-selection teams** — capacity and competitor gaps by county across states.
- **Journalists & researchers** — cross-state compliance analysis.

### Input examples

- All five states, full compliance merge: `{}`
- Just the inspection states: `{ "states": ["CT", "DE"] }`
- One county: `{ "states": ["DE"], "county": "Sussex" }`
- Compliance screen (DE deficiencies): `{ "states": ["DE"], "minDeficiencies": 5 }`
- Fast licensing-only pull: `{ "includeInspections": false }`

### Input reference

| field | meaning |
|---|---|
| `states` | subset of `["NY","NJ","CO","CT","DE"]` (default: all) |
| `county` | one county; server-side where the feed has a county column (CT has none) |
| `licenseStatus` | case-insensitive substring on license status |
| `includeInspections` | merge inspection/deficiency feeds (CT, DE). default `true` |
| `minDeficiencies` | only facilities with ≥ N cited deficiencies (DE only) |
| `maxRecordsPerState` | cap facilities per state |
| `maxInspectionRows` | cap inspection rows read per state before building the lookup |

### Proof

`npm run smoke` (or `node test_smoke.mjs`) pulls real rows from every state against the live endpoints,
asserts content + state tagging, and proves the CT/DE compliance joins produce non-null counts on real
facilities. No account, no cost — all sources are public state open-data portals accessed logged-out.

### Source & legality

Official state open-data portals (data.ny.gov, data.nj.gov, data.colorado.gov, data.ct.gov,
data.delaware.gov), public, accessed logged-out via the Socrata SODA API. Re-run monthly for current
license and compliance status.

[Texas Childcare Licensing + Violations]: ../childcare-licensing-tx

# Actor input Schema

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

Which states to pull. Available: NY (16.8k facilities), NJ (4.2k), CO (4.5k), CT (16.2k + inspections), DE (1.2k + inspections & deficiencies). Leave empty for all five.

## `county` (type: `string`):

Filter to one county (e.g. 'Sussex', 'Oneida', 'Boulder'). Applied server-side where the state feed carries a county column; CT publishes no county so a county filter returns no CT rows. Leave empty for statewide.

## `licenseStatus` (type: `string`):

Case-insensitive substring match on the facility's license status (e.g. 'ACTIVE', 'License', 'Licensed'). Leave empty for all statuses.

## `includeInspections` (type: `boolean`):

When on, fetch each state's inspection/deficiency feed and merge per-facility inspection\_count and (DE) deficiency\_count + top cited regulations. Turn off for a faster, licensing-only pull. Only affects CT and DE.

## `minDeficiencies` (type: `integer`):

Only return facilities with at least this many cited deficiencies (compliance screening). Deficiency counts are published only by Delaware; other states have none, so this filter excludes them.

## `maxRecordsPerState` (type: `integer`):

Cap the number of facility records pulled from each state (leave empty for the full registry).

## `maxInspectionRows` (type: `integer`):

Cap the inspection/deficiency rows fetched per state before building the per-facility compliance lookup (leave empty to read the full feed; CT ships ~97k inspection rows).

## Actor input object example

```json
{
  "states": [
    "CT",
    "DE"
  ],
  "includeInspections": true
}
```

# 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": [
        "CT",
        "DE"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("civicdataforge/multistate-childcare-licensing").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": [
        "CT",
        "DE",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("civicdataforge/multistate-childcare-licensing").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": [
    "CT",
    "DE"
  ]
}' |
apify call civicdataforge/multistate-childcare-licensing --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-State Childcare Licensing + Inspections",
        "description": "Licensed childcare facilities across NY, NJ, CO, CT and DE in one unified schema — name, type, address, county, capacity, license status — plus the compliance record where the state publishes it: inspection counts (CT, DE) and cited-deficiency detail (DE).",
        "version": "0.1",
        "x-build-id": "yoEYZih8rWBXBcDKP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/civicdataforge~multistate-childcare-licensing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-civicdataforge-multistate-childcare-licensing",
                "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/civicdataforge~multistate-childcare-licensing/runs": {
            "post": {
                "operationId": "runs-sync-civicdataforge-multistate-childcare-licensing",
                "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/civicdataforge~multistate-childcare-licensing/run-sync": {
            "post": {
                "operationId": "run-sync-civicdataforge-multistate-childcare-licensing",
                "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",
                        "type": "array",
                        "description": "Which states to pull. Available: NY (16.8k facilities), NJ (4.2k), CO (4.5k), CT (16.2k + inspections), DE (1.2k + inspections & deficiencies). Leave empty for all five.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "Filter to one county (e.g. 'Sussex', 'Oneida', 'Boulder'). Applied server-side where the state feed carries a county column; CT publishes no county so a county filter returns no CT rows. Leave empty for statewide."
                    },
                    "licenseStatus": {
                        "title": "License status",
                        "type": "string",
                        "description": "Case-insensitive substring match on the facility's license status (e.g. 'ACTIVE', 'License', 'Licensed'). Leave empty for all statuses."
                    },
                    "includeInspections": {
                        "title": "Include inspection / deficiency data",
                        "type": "boolean",
                        "description": "When on, fetch each state's inspection/deficiency feed and merge per-facility inspection_count and (DE) deficiency_count + top cited regulations. Turn off for a faster, licensing-only pull. Only affects CT and DE.",
                        "default": true
                    },
                    "minDeficiencies": {
                        "title": "Min cited deficiencies",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return facilities with at least this many cited deficiencies (compliance screening). Deficiency counts are published only by Delaware; other states have none, so this filter excludes them."
                    },
                    "maxRecordsPerState": {
                        "title": "Max records per state",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap the number of facility records pulled from each state (leave empty for the full registry)."
                    },
                    "maxInspectionRows": {
                        "title": "Max inspection rows per state",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap the inspection/deficiency rows fetched per state before building the per-facility compliance lookup (leave empty to read the full feed; CT ships ~97k inspection rows)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```