When members visit their health plan’s website, finding an in-network provider is usually the single most important thing they came to do. If that search lives somewhere else, on a third-party portal with its own design, its own quirks, and its own dead ends, the experience breaks at the moment it matters most.
So when a client asks us to bring a service like provider search directly into their website, I’m a fan. A consolidated experience keeps people oriented. They stay on a site they trust, and the organization keeps ownership of an experience that reflects on them either way.
One of our healthcare insurance clients recently asked for exactly this: a provider search built into one of their web properties, so members could find in-network care without leaving the site. I want to walk through how my team approached it, because with API integrations the process matters more than the technology.
Start with the people, not the API
The temptation on any integration is to go straight to the technology. Get API credentials, read the docs, start building.
We started with people. Before writing code, we talked with the experts inside and alongside our client’s organization, the folks who know what the data represents, where it comes from, and where it falls short in practice. Provider network data shifts constantly. Specialties, locations, plan participation, whether a practice is accepting new patients. The people who work with that data daily know where it can be trusted and where it can’t.
Those conversations gave us our guardrails. They told us which filters would help a member, which fields were reliable enough to surface, and where we needed to design around gaps.
Expect imperfect documentation, and plan for it
From there, we got access to the API and its documentation. Here’s something I’ve learned across many integration projects: documentation for services like this is often spotty. Endpoints go undescribed. Fields show up in responses that no document mentions. What’s written and what’s deployed drift apart.
I treat that as part of the job. Our work is to understand the system as it exists, whatever the documentation says, and to fill the gaps ourselves through testing and observation. Working closely with our client, we mapped the full schema and architecture of the API and built a picture of what was available to us.
That picture is what makes good decisions possible. Once we knew what the API could do, we designed a search that exposed the available filters in a way that made sense for the people using it.
The question worth asking: connect directly, or transform the data?
With most integrations there’s a fork in the road. You can connect directly to the API, passing queries through and displaying what comes back. Or you can consume the data on a schedule, store it, and reshape it into something more useful for the member: faster searches, smarter groupings, friendlier presentation.
The second path is appealing, and often the right call. It also carries trade-offs. If the source data updates and your copy doesn’t, members may see providers listed in the wrong network. If the connection fails silently, the gap can persist without anyone noticing. A direct connection avoids those risks and limits how much you can improve on what the API gives you.
There’s no universal answer here. We weigh the downsides against the goals the organization wants to hit, and we put the trade-offs in front of the client instead of deciding behind the curtain. I’d rather surface a risk early, even when it complicates delivery. That’s how the final decision ends up being one the client can stand behind and maintain.
Prove it with a prototype
The end result of our exploration was a prototype: a working concept showing how we could retrieve data from the API and how it could be displayed to a member searching for care. From there, the prototype became the foundation for my development team to build a full-scale application.
I’m a fan of prototypes for one reason: they let people react to something they can click. The experts we talked to at the start got to poke at it. The practical questions surfaced early, while they were still cheap to answer. And the engineering work that followed started from what the system could do, instead of what a proposal hoped it could.
What this means for your organization
If you’re thinking about bringing a third-party service into your healthcare website, whether it’s a provider search, a member directory, or something else, the pattern holds. Talk to the people who know the system before you talk to the system. Expect incomplete documentation and budget time to learn what’s there. Weigh a direct connection against transformed data honestly, with the member’s experience and your team’s capacity in view. And ask for a working prototype before you commit to a full build.
We’ve followed this pattern before. Our integration work with ChenMed connected an expanding network of medical centers with the same integration-first thinking.
What am I missing? If you’ve run an integration like this and solved it differently, I’d love to hear how you handled it.
And if you’re weighing one now, let’s talk it through. Start a conversation.
