Build vs buy provider network data: the effort, compared.
By our estimates, a first in-house pipeline covering about ten insurers takes 3 to 6 engineer-months, and keeping it current takes half to one and a half engineers for as long as you run it. An API takes a day or two to integrate and a monthly fee. Build when network data is the product you sell, or when your scope is small, fixed and already in hand.
Every number of weeks and engineers on this page is an estimate, stated as a range. Your figures depend on how many insurers and markets you need, how fresh answers must be, and how much of the work your team has done before. Use the ranges to size the question, then test both paths against providers you know.
What a team must build
Insurers publish provider directories, and public registries describe plans and providers. That makes building possible. A pipeline that answers "does this plan list this provider?" well needs every part below, and the second column is only the first version.
| PART | FIRST BUILD (ESTIMATE) | TO KEEP IT RUNNING |
|---|---|---|
| Finding each insurer’s published directories, per plan year | 1 to 3 days per insurer | A few hours per insurer a month, more in the weeks a new plan year opens |
| Downloading and parsing very large files | 3 to 6 weeks for the framework, then 2 to 5 days per insurer | Fixes whenever an insurer changes structure, often with no notice |
| Refreshing every month | 1 to 2 weeks to schedule, retry and resume | Compute and bandwidth on every run; reruns after failures |
| Matching plan IDs to networks | 2 to 4 weeks | A fresh mapping pass for each new plan year |
| Matching providers and adding names, credentials and locations from public registries | 1 to 3 weeks | A monthly registry refresh |
| Storage and fast lookups over hundreds of millions of rows | 2 to 4 weeks | Database cost, index and disk upkeep |
| Monitoring: freshness, row counts, runs that load nothing | 1 to 2 weeks | Someone who reads the alerts and fixes the cause |
| Answer rules: dates on every answer, plan years kept apart, a meaning for not found | 1 to 2 weeks | Small, but every new screen has to respect them |
Added up for about ten insurers, the first build lands at roughly 3 to 6 engineer-months. Each insurer you add after that costs days, not weeks, once the framework exists. The range is wide because insurers differ: some publish tidy, small directories, and some publish files so large that reading them is a project of its own.
Where the time really goes
- Size. A large national insurer's directory can be far larger than the data most product teams handle. Reading it needs streaming parsers, disk to stage it and hours of compute per run. InPlan holds more than 650 million provider-plan links today; a pipeline with similar reach stores a similar order of rows.
- Change. Directories move, change structure and change content during the year. Each insurer is a separate integration that can break on its own schedule.
- Silent failure. The worst failure is a run that finishes without error and loads nothing, or loads last month's data again. Answers go stale with no alarm. Monitoring must check that each run produced real rows for each insurer, not only that the job ended.
- Plan years. Every year brings new plan IDs, and for a while two plan years are live at once. The mapping from directory networks to the plan IDs your users hold has to be rebuilt each time.
- Meaning. "Not found" must never become "out of network" in your product. Getting that right is a design decision, and our guide to showing network status honestly covers it.
Side by side
| BUILD | BUY AN API | |
|---|---|---|
| Time to first answer | Months (estimate) | Minutes with a free key |
| Upfront effort | 3 to 6 engineer-months for about ten insurers (estimate) | 1 to 2 days to integrate (estimate) |
| Ongoing effort | 0.5 to 1.5 engineers, plus storage and compute (estimate) | A subscription; your code calls one endpoint |
| Control over fields and schedule | Full | What the API returns, at its refresh pace |
| Dates and sources on each answer | You design and store them | Returned on every answer here |
To turn the build column into money, multiply the engineer-months by what an engineer costs your company, then add infrastructure. To price the buy column, see below. Compare them over two or three years, not one, because the build cost does not stop after launch.
When building is the right call
- Network data is your product. If you sell the data, the pipeline is your moat and you should own it. Buying can still get you to market while you build.
- Your scope is small and fixed. One or two insurers in one state, with a team that already reads their files, can be cheaper to run in house.
- You need fields an API does not return. If your product depends on directory detail beyond plan, provider and date, owning the read may be the only way to get it.
- Your volume is very large. At very high call volumes, compare the per-call price with your build estimate honestly. Bulk data files can also close that gap.
Many teams do both in order: buy first to learn which providers and plans matter to their users, then build only the part that is truly theirs. Our build or buy guide lists the questions to ask any vendor, including us.
Test the buy side in one call
Look up a provider your users know. One call returns who they are and a summary of the plans that list them.
# what is held for one provider, across both markets curl -H "Authorization: Bearer $INPLAN_KEY" \ "https://api.inplan.io/v1/providers/1376006148"
"plan_summary": {
"aca": { "plans": 199, "issuers": 8, "states": ["GA", "NC", "SC", "TN"],
"plan_years": [2025, 2026, 2027], "as_of": "2026-10-29" },
"ma": { "plans": 146, "organizations": 4, "as_of": "2026-10-29" }
}That one family physician is listed in 199 marketplace plans from 8 insurers and 146 Medicare Advantage plans from 4 organizations, each with a read date. A home-built pipeline has to produce that for every provider your users search.
What buying costs here
The free tier gives 500 calls a month with no credit card. Builder is $199 a month for 25,000 calls and adds batch checks. Growth is $599 a month for 150,000 calls and adds the providers-in-a-plan call. For analysis rather than single checks, a data file holds every provider in a state with every plan that lists them, from $299. Full details are on the pricing page, and what we hold is on the coverage page.