Start filing →
Home/Business OS/API
API & Webhooks · Scale

File with all 51 states from your own code.

Building a platform that forms companies or keeps them compliant means integrating with 51 different state systems, each with its own quirks. The File.Business API is one clean REST interface for all of them: formations, filings, entity lookups, and compliance, with webhooks for everything that happens asynchronously.

Read the docs Try the API
REST + webhooks Sandbox included Node & Python SDKs
Live product

One interface for fifty-one state systems.

This is the API playground. Pick an endpoint, send the request, and read the JSON back, the same call your integration would make in production.

sandbox · sk_test_...9f2
Request 

        

        

          
Responseready

          

        

      

      

        Every call runs against a sandbox that mirrors production, no state fees.
        Avg response ~180ms
      

    

  







  

    Why it exists
    
Fifty-one integrations, or one.

    

      
If your product needs to form entities or keep them compliant, the honest cost isn't the filing, it's the plumbing. Every state runs its own system, its own forms, its own fees and quirks, and none of them were built for programmatic access. Wiring up even a handful yourself is a project that never really ends, because the states keep changing underneath you.

      
That's work that doesn't differentiate your product. Your customers don't care that you integrated with a specific Secretary of State; they care that the thing works. Every engineering week spent on state plumbing is a week not spent on what your platform is actually for.

      
The File.Business API is that plumbing, done once, behind one interface. You call a single REST endpoint to create a filing, look up an entity, or subscribe to an event, and we fulfill it across all 51 jurisdictions, keep up with their changes, and hand back clean JSON. Your integration stays the same even as the states don't.

    

  







  

    How it works
    
Key, sandbox, call, webhook.

    
From first request to production integration, the path is short and the surprises are few.

    

      
01Get a keyScoped sandbox and live keys you can rotate anytime, with bearer-token auth over HTTPS.

      
02Build in the sandboxThe sandbox mirrors production, so you exercise every response and webhook with no state fees.

      
03Call the endpointsCreate filings, look up entities, and manage compliance through plain REST, with typed SDKs.

      
04Listen on webhooksSubscribe to signed events like a filing completing, so async results reach your systems.

    

  







  

    Built for integrators
    
The details that make an API pleasant to build on.

    

      
Full sandboxA production mirror where you can run filings end to end without touching an agency or a fee.

      
Signed webhooksSubscribe to events, verify each with a signature, and rely on automatic retries if you're briefly down.

      
Idempotency keysAn Idempotency-Key header means a retry never files twice, even through a network hiccup.

      
Typed SDKsNode and Python client libraries with typed responses, and plain REST for any other language.

      
Dated versioningPin a date-based version; a future upgrade never changes behavior under you without notice.

      
Predictable limitsRate limits in response headers and cursor-based pagination, so paging and backoff are stable at scale.

    

  







  

    Where it sits in the OS
    
The API exposes the whole OS to your code.

    
Everything the platform does through the dashboard, your systems can do through the API, under the same permissions.

    

      Bulk FilingsTrigger batches programmatically and receive acceptance webhooks as each entity clears.Explore 
      Business SearchPull entity lookups as JSON and subscribe to changes on any entity you watch.Explore 
      White LabelPut your brand on the client-facing experience while the API fulfills the filings behind it.Explore 
      Team AccountsAPI keys carry the same roles and scopes, so integrations respect your permission model.Explore 
      Document VaultReceipts and filed documents are retrievable by API, so your system holds proof too.Explore 
      Developer HubReference, guides, and SDK docs, the fastest path from a key to a working integration.Explore 
    

  







  

    

      FAQ
      
API, answered.

    

    

      
What can I do with the API?
Anything the platform does: form entities, file annual reports and other state filings, run bulk batches, look up any US company, retrieve documents and receipts, and subscribe to compliance events. It's the same capability set as the dashboard, exposed as REST so your own product can drive it end to end.

      
How does authentication work?
Bearer-token authentication over HTTPS. You get scoped sandbox and live keys that you can rotate any time from the dashboard, requests without a valid key are rejected, and keys never appear in URLs or logs. Keys also carry the same roles and scopes as your team permissions, so an integration can't exceed what its key is allowed to do.

      
How do webhooks work?
Register an endpoint and subscribe to events like a filing completing or a deadline approaching. Each event is signed so you can verify it came from us, and if your endpoint is briefly unavailable we retry with backoff, so an outage on your side doesn't lose an event. It's how asynchronous state results reach your systems reliably.

      
How do you prevent duplicate filings on retry?
Send an Idempotency-Key header with a create request. If the same key is retried, we return the original result instead of filing again, so a network hiccup or a client retry never files, or pays for, the same thing twice. It's the safety net that makes automated filing safe to build on.

      
Are there SDKs?
Yes. There are client libraries for Node and Python with typed responses, and the REST API is plain enough to call from any language. The developer hub has guides, references, and examples, so the path from a key to a working call is short.

      
How do rate limits and pagination work?
Rate limits are returned in response headers so your backoff can be predictable under load, and list endpoints use stable cursor-based pagination rather than offsets, so paging over large result sets stays consistent even as data changes underneath you. Both are the small things that decide whether an integration is pleasant at scale.

      
Can I run the API under my own brand?
Yes. Combine the API with white-label so the client-facing experience your API powers carries your brand, while File.Business fulfills the filings across 51 jurisdictions behind the scenes. Your customers see you; we handle the states.

    

  







  

    
Ship filings, not state integrations.

    
Build on one REST API that covers all 51 jurisdictions, with a sandbox, signed webhooks, and SDKs, so your team stays focused on your product.

    

      Read the docs 
      Request API access
    

    

      REST + webhooks
      Sandbox
      Node & Python
    

  




API & WebhooksDocs →