Discover/Pa API
live

Pa APIfile.dos.pa.gov

Search and retrieve Pennsylvania Department of State business entity records including registration details, officers, addresses, and filing history via two REST endpoints.

This API takes change requests — .
Endpoint health
monitored
get_entity_details
search_entities
Checks pendingself-healing
Endpoints
2
Updated
2h ago

What is the Pa API?

This API provides access to Pennsylvania Department of State business entity data through 2 endpoints. Use search_entities to query the statewide business registry by name or entity number, returning status, entity type, jurisdiction, and standing for every match. Use get_entity_details to pull a full record for a specific entity, including registered agent, principal address, officers, and a complete filing history.

This call costs2 credits / call— charged only on success
Try it
Entity name or entity number to search for.
Match mode for the query. Omitting defaults to 'starts_with'.
api.parse.bot/scraper/c4b6d613-109b-445f-a391-e1e7ddcb2cc7/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/c4b6d613-109b-445f-a391-e1e7ddcb2cc7/search_entities?query=GOOGLE&search_type=starts_with' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

Typed, relational, agent-ready

A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.

  • Fully typed · autocompletes
  • Objects link to objects
  • Typed errors & pagination

Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:

uv add parse-sdk
uv run parse init
uv run parse add --marketplace file-dos-pa-gov-api

uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.

"""Walkthrough: PA Business Entity Search — search, navigate, and inspect details."""
from parse_apis.file_dos_pa_gov_api import PaBusinessSearch, SearchType, EntityNotFound

client = PaBusinessSearch()

# Search for entities whose name starts with a keyword; cap total items.
for summary in client.entity_summaries.search(query="GOOGLE", search_type=SearchType.STARTS_WITH, limit=5):
    print(summary.entity_name, summary.entity_type, summary.standing)

# Drill into the first match's full details via summary-to-detail navigation.
hit = client.entity_summaries.search(query="GOOGLE", limit=1).first()
if hit is not None:
    detail = hit.details()
    print(detail.entity_name, detail.status, detail.jurisdiction)
    print("Business activity:", detail.business_activity)
    print("Formation:", detail.formation_date)

    # Walk nested typed objects: officers and filing history.
    for officer in detail.officers:
        print("  Officer:", officer.name, officer.role)
    for filing in detail.filing_history:
        print("  Filing:", filing.type, filing.date, filing.status)

    # Registered office address (nullable — guard before access).
    if detail.registered_office_address is not None:
        addr = detail.registered_office_address
        print("  Office:", addr.street, addr.city, addr.state, addr.postal_code)

# Point lookup by entity number discovered from a prior search result.
if hit is not None:
    try:
        entity = client.entities.get(entity_number=hit.entity_number)
        print(entity.entity_name, entity.standing, entity.term_of_duration)
    except EntityNotFound:
        print("Entity not found for", hit.entity_number)

print("exercised: entity_summaries.search / EntitySummary.details / entities.get")
All endpoints · 2 totalmissing one? ·

Search the Pennsylvania Department of State business entity database by entity name or entity number. Supports 'starts with' and 'contains' matching. Returns all matching entities with their entity number, name, type, status, initial filing date, jurisdiction, and standing. The single upstream call returns all matches without pagination. Searching by entity number (numeric input) also works through the same name search field.

Input
ParamTypeDescription
queryrequiredstringEntity name or entity number to search for.
search_typestringMatch mode for the query. Omitting defaults to 'starts_with'.
Response
{
  "type": "object",
  "fields": {
    "query": "The search query that was executed",
    "entities": "Array of matching business entities",
    "search_type": "The match mode used (starts_with or contains)",
    "total_results": "Number of matching entities returned"
  },
  "sample": {
    "data": {
      "query": "GOOGLE",
      "entities": [
        {
          "status": "Active",
          "standing": "Not Good Standing",
          "entity_name": "GOOGLE PAYMENT CORP.",
          "entity_type": "Foreign Business Corporation",
          "filing_date": "04/14/2005",
          "former_name": null,
          "jurisdiction": "DELAWARE",
          "entity_number": "0003299074"
        }
      ],
      "search_type": "starts_with",
      "total_results": 12
    },
    "status": "success"
  }
}

About the Pa API

Searching the Pennsylvania Business Registry

The search_entities endpoint accepts a query string (entity name or entity number) and an optional search_type parameter that controls whether results match on starts_with or contains. The response includes an array of matching entities, each carrying the entity number, name, entity type (e.g., Domestic Limited Liability Company, Foreign Business Corporation), current status, initial filing date, jurisdiction, and standing. The total_results field tells you how many records matched without needing to count the array.

Retrieving Full Entity Details

The get_entity_details endpoint takes a 10-digit zero-padded entity_number — the same value returned in search_entities results. Shorter numeric strings are automatically padded. The response includes the official entity_name, entity_type, formation_date in ISO format, jurisdiction, status, standing, registered_agent name, and two address fields for the registered office and principal location. The officers array lists each officer or governor with their name, title, and role. The filing_history array provides every recorded filing entry with its type, date, status, and Document Locator Number (DLN).

Data Coverage and Scope

Data reflects Pennsylvania Department of State records for domestic and foreign business entities registered to operate in Pennsylvania. Entity types span corporations, LLCs, LPs, LLPs, and other recognized forms. Status values include Active and Inactive variants such as "Inactive - Withdrawn". The filing history gives a full chronological view of document submissions, making it useful for due diligence and compliance workflows.

Reliability & maintenance

The Pa API is a managed, monitored endpoint for file.dos.pa.gov — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when file.dos.pa.gov changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.

This isn't an official file.dos.pa.gov API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.

Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Verify good standing and active status of a Pennsylvania vendor before contract execution
  • Retrieve officer and governor names for a PA-registered LLC during a KYC or background check workflow
  • Enumerate all filings by type and date for a business entity to assess compliance history
  • Identify the registered agent on record for legal service or correspondence purposes
  • Bulk-search entities by name fragment using 'contains' mode to find related companies under a common brand
  • Cross-reference jurisdiction field to distinguish domestic PA entities from foreign entities registered in PA
  • Automate monitoring of entity status changes by periodically fetching details via entity number
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 req/min

Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does the Pennsylvania Department of State provide an official developer API for this data?+
The Pennsylvania Department of State does not publish a documented public developer API for business entity searches. The data is made available through the public search portal at file.dos.pa.gov/search/business.
What does the officers array in get_entity_details actually contain?+
The officers array returns one object per listed officer or governor, each containing the individual's name, their title (e.g., President, Secretary, Manager), and their role designation as recorded with the Department of State. It reflects whoever is on file at the time of the request — it does not include historical officer appointments that have since been removed.
Can I retrieve registered office address and principal office address separately?+
Yes. The get_entity_details response distinguishes between the registered office address (used for legal and official correspondence) and the principal office address (the main place of business). Both are returned when on file with the Department of State.
Does the API cover Pennsylvania UCC filings, charity registrations, or professional licenses?+
Not currently. The API covers business entity registration records — searches and detailed entity profiles including officers, standing, and filing history. UCC filings, charitable organization registrations, and professional license data are separate Pennsylvania DOS systems not included in these endpoints. You can fork this API on Parse and revise it to add endpoints targeting those other record types.
Is there a way to paginate through large result sets from search_entities?+
The current search_entities endpoint returns all matching entities for a given query in a single response, along with a total_results count. There is no pagination parameter exposed. For very broad queries, using starts_with mode or a more specific query string will narrow results. You can fork this API on Parse and revise it to add pagination parameters if the source supports them.
Page content last updated . Spec covers 2 endpoints from file.dos.pa.gov.
Related APIs in Government PublicSee all →