- Which Integration Path Should You Choose: Direct, Aggregator or Custom Layer?
- Which Lifecycle APIs Does a Carrier Integration Need?
- How Do You Secure Carrier API Calls and Keep Them Compliant?
- How Do You Normalize Data From Different Carriers?
- How Should Your App Handle Slow Carrier Responses?
- How Do You Test and Certify a Carrier Integration?
- How Do You Actually Get Carrier API Access?
- How Does Space-O Canada Help With Insurance Carrier API Integration?
- Frequently Asked Questions About Integrating Carrier APIs
How to Integrate Insurance Carrier APIs Into an App: A Complete Guide

Key Takeaway
- Path choice: weigh direct, aggregator and custom orchestration routes on control, compliance and system fit.
- Data model: map every carrier into one ACORD-aligned canonical schema through per-carrier adapters.
- Compliance: apply OAuth 2.0, mTLS, encryption and audit logging, mapped to GLBA, NAIC and PIPEDA duties.
- Reliability: absorb slow carrier responses with webhooks, idempotency keys, circuit breakers and dead letter queues.
- Access: clear carrier access gates through partnerships, licensing, IP allowlisting, mTLS and certification sign-off.
To integrate carrier APIs, choose a direct, aggregator or custom orchestration path, build quoting first and treat policyholder data as regulated. Then map the bind, policy servicing and claims calls, and normalize mismatched carrier formats through one translation layer. Secure every call against GLBA, NAIC and NIST Cybersecurity Framework expectations, and test each carrier in a sandbox before go-live.
Carrier integrations rarely break on code. Most break when a carrier withholds production access or returns a schema nobody mapped. Others break when a compliance review lands after launch. Each failure forces rework after the architecture is already locked.
The risk grows with every carrier you add. Insurers and fintech startups adding quoting, binding or claims to an app rarely stop at one carrier, and each new connection brings its own access rules, data format and security review.
Every one of those connections also carries policyholder data, so security belongs in the integration plan from the start. According to IBM, a data breach in financial services cost an average of $6.3 million in 2026.
An experienced Insurance App Development Company plans access, data mapping and security together from the first carrier onward. Start with the integration path, because it shapes every decision after it.
Which Integration Path Should You Choose: Direct, Aggregator or Custom Layer?
Every carrier integration starts with one fork: connect to each carrier directly, or go through a unified aggregator API. A third route, a custom orchestration layer, can sit across both.
1. Direct carrier integration connects to each carrier one by one
Direct integration means building a separate connection to each carrier’s own API. Each carrier needs its own mapping, authentication and test cycle.
Lemonade is one example of a carrier that exposes its own API. Direct work gives the deepest product access, but effort grows with every carrier you add.
- Pro: full access to each carrier’s products, fields and rating rules.
- Pro: no intermediary between your app and the carrier’s systems.
- Con: a new mapping, auth setup and certification for every carrier.
- Con: each carrier’s API change lands directly on your team.
2. A unified aggregator API puts many carriers behind one interface
A unified aggregator API sits in front of many carriers and absorbs their differing data schemas behind one interface. Your app calls one API, and the aggregator handles carrier-specific formats. Examples include InsurGrid, CoverGo, Canopy, SelectsysTech, SANDIS and insureMO. Adopting one means fitting your product to its normalized schema and its supported carrier list. Insurtech startups weighing these platforms can compare features, cost and compliance in the insurtech app development guide.
- Pro: one integration reaches every carrier the aggregator already supports.
- Pro: the aggregator absorbs most carrier API changes before they reach your app.
- Con: your data model follows the aggregator’s schema, not your own workflows.
- Con: carriers outside the aggregator’s network still need separate integration work.
3. A custom orchestration layer maps every carrier into your own model
A custom orchestration layer sits between your app and every carrier, translating each carrier’s API into a canonical data model you own. The layer plugs into the policy administration, rating and claims systems already in place, and it can run direct carrier links and an aggregator side by side. Older policy and claims platforms stay in service while the layer replaces them piece by piece. Space-O Canada builds this layer with one in-house team, from discovery through post-launch support.
- Pro: your canonical model stays yours as carriers come and go.
- Pro: compliance scope is mapped before any carrier code ships.
- Con: discovery and design work comes before the first carrier connects.
- Con: you own the layer, so maintenance continues after launch.
4. The three paths differ on compliance, ownership and speed
The table compares each route on the factors that decide production fit.
| Factor | Direct carrier integration | Unified aggregator API | Custom orchestration layer |
|---|---|---|---|
| Where compliance scope is mapped | Per carrier, by your team | Partly inside the aggregator’s controls | In discovery, across all carriers |
| Who owns carrier-specific mapping | Your team, per carrier | The aggregator | Your team, through a canonical model built with your partner |
| Fit with core systems you already run | Separate work for each carrier link | Depends on the aggregator’s connectors | Built around your policy, claims or core systems |
| Post-launch support | Your own team | The aggregator’s support terms | The same in-house team that built it |
| Speed to market | Slows as carrier count grows | Fast where your carriers are already supported | Depends on discovery scope and carrier count |
| Per-carrier effort | High for each new carrier | Low inside the network, high outside it | One new adapter per carrier |
Find the Right Integration Path for Your Carriers
Space-O Canada engineers weigh direct, aggregator and custom routes against your carrier list, core systems and compliance scope, then recommend one path.

The path you choose decides who owns mapping, compliance and support for the life of the integration. Once the route is set, the next decision is which lifecycle calls the app must make.
Which Lifecycle APIs Does a Carrier Integration Need?

A carrier integration needs six API groups: quoting and rating, submission, binding, documents, policy servicing and claims. Quoting anchors the set, and each group handles one job:
- Quoting and rating: returns a premium from applicant and risk data. Some carriers return several coverage options, while others refer the risk for manual review.
- Submission: sends a full application to the carrier for underwriting review. Underwriters may ask for extra details or adjust terms before approving the risk.
- Binding: converts an accepted quote into an active policy. The carrier returns a policy number and effective date, which every later call references.
- Documents: retrieves declarations, policy forms and certificates for the policyholder. Your app can store these for self-service download instead of routing requests through an agent.
- Policy servicing: handles endorsements, renewals and cancellations after binding. Each change can trigger a premium adjustment and a fresh set of documents.
- Claims: opens a claim and returns status updates as it moves forward. First notice of loss details, photos and adjuster notes travel through the same connection.
The endpoint patterns below are illustrative. Each carrier names its routes differently, and your adapters translate them.
| Endpoint | Purpose |
|---|---|
| POST /quotes | Request a quote from applicant and risk data. |
| GET /quotes/{id} | Fetch a quote that completed asynchronously. |
| POST /submissions | Send a complete application for underwriting. |
| POST /quotes/{id}/bind | Bind an accepted quote into a policy. |
| GET /policies/{id}/documents | Download declarations and policy forms. |
| PATCH /policies/{id} | Apply an endorsement or other servicing change. |
| POST /claims | Open a claim against an active policy. |
Documents and servicing calls shape what policyholders see after binding. Declarations often arrive as files rather than structured fields, and endorsement or renewal data powers the policy management features for insurance apps your users rely on.
Servicing, documents and claims all hang off a bound policy, and every one of these calls carries regulated data, so security comes next.
How Do You Secure Carrier API Calls and Keep Them Compliant?

Secure carrier API calls with OAuth 2.0, mTLS, encryption and audit logging, and map each control to GLBA, NAIC and NIST requirements. Carrier APIs move personal and financial data, so one weak control becomes a regulatory finding. Security belongs in the architecture, not in a late QA pass.
1. GLBA, NAIC and NIST set the US compliance baseline
GLBA, NAIC model laws and the NIST Cybersecurity Framework form the US baseline for insurance data. GLBA governs how insurers protect customer financial information. The law also limits how nonpublic personal information is shared with carriers and other third parties.
NAIC model laws shape state insurance data security rules. The Insurance Data Security Model Law, for example, requires licensees to run a written information security program and report cybersecurity events to the state commissioner. The NIST Cybersecurity Framework structures how you manage cybersecurity risk. The framework groups that work into six functions: Govern, Identify, Protect, Detect, Respond and Recover.
If the app takes card payments at bind, PCI-DSS covers that flow. Carriers also run their own security reviews before approving you. Expect security questionnaires, penetration test evidence and proof of encryption controls during those reviews.
2. Every carrier call needs the same core controls
Apply each control to small and large carriers alike, with no looser set for low-volume partners. One weak connection exposes the same policyholder records as every other link. Claims flows often carry the most sensitive records, so see how to build a secure insurance claims app with these controls in place.
- OAuth 2.0: issues short-lived tokens so a leaked credential expires quickly. Scope each token to the calls that integration actually needs.
- Mutual TLS (mTLS): proves both your server and the carrier’s server are genuine. Carriers often require it before opening production endpoints.
- IP allowlisting: lets a carrier accept traffic only from your registered addresses. Keep outbound IPs static so a cloud change does not break carrier access.
- Encryption in transit and at rest: protects data on the wire with TLS and in storage with AES-256. Rotate keys on a schedule and keep them in a managed key service.
- Role-based access control: restricts which staff can view policyholder records. Least-privilege defaults mean new staff start with no access until a role grants it.
- Audit logging: records every quote, bind and claim call for later review. Tamper-evident logs hold up when a regulator or carrier asks for evidence.
- API gateway: acts as the gatekeeper that enforces auth, rate limits and logging. Centralizing these rules keeps controls consistent as you add carriers.
3. Canadian markets add PIPEDA, FINTRAC and OSFI duties
Cross-border insurers face Canadian rules alongside US ones. Space-O Canada engineers platforms to support PIPEDA for personal information. PIPEDA requires consent to collect and share personal information, and it requires reporting breaches that pose a real risk of significant harm to the Privacy Commissioner. Quebec’s Law 25 also requires a privacy impact assessment before personal information is transferred outside Quebec.
OSFI guidelines apply to federally regulated insurers, and FINTRAC reporting duties apply to life insurance companies, brokers and agents. OSFI Guideline B-13 sets expectations for technology and cyber risk, and Guideline B-10 covers third-party risk, including the vendors that build or host your integration.
Map these duties separately from GLBA and NAIC obligations during discovery. Provincial regulators, such as FSRA in Ontario and the AMF in Quebec, can add their own requirements on top.
Map Your Carrier Compliance Scope Early
Our team maps GLBA, NAIC and PIPEDA duties across every carrier during discovery, so compliance reviews land before launch, not after.
Securing each connection solves only half the problem. The harder half is that each carrier sends data in a different shape.
How Do You Normalize Data From Different Carriers?

No two carriers return a quote in the same format, even for the same product line. A translation layer turns that variety into one model your app understands.
1. SOAP/XML and REST/JSON both appear in carrier APIs
Many established carriers still expose SOAP/XML services, while newer carriers publish REST/JSON APIs. Your app logic should never care which protocol a carrier uses. SOAP services usually ship with a WSDL contract, while REST APIs tend to document endpoints with OpenAPI.
Per-carrier adapters convert each protocol into one internal format before data reaches pricing, underwriting or display logic. Upgrading one carrier’s protocol then touches a single adapter, not the whole app.
2. ACORD gives carriers shared data definitions
ACORD data standards give the insurance industry shared definitions for policies, coverages and parties. An ACORD-aligned canonical model cuts down one-off field translations. ACORD publishes XML standards and newer API-oriented data standards, so the same definitions carry across older and newer carrier systems.
Carriers apply ACORD unevenly, so adapters still close carrier-specific gaps. Keep a field-mapping document per carrier so the team can trace every custom code, extension field or renamed value.
3. The canonical model keeps carrier quirks at the edge
A canonical model works when every carrier maps into it and nothing maps around it. Any shortcut that lets app code read raw carrier fields brings carrier quirks back into the core.
- Define one internal schema for applicants, risks, quotes, policies and claims. Base field names on ACORD where possible so new carriers map faster.
- Build one adapter per carrier that maps its fields into that schema. Keep carrier-specific codes and rules inside the adapter, not in shared services.
- Validate every inbound payload against the schema before storing it. Send rejected payloads to a review queue with the carrier name and failed field attached.
- Version the schema so one carrier’s change never breaks the others. Adapters can then move to a new version one carrier at a time.
With every carrier mapped into one schema, a carrier quirk stays inside its own adapter. Slow and uneven carrier responses are the next risk to contain.
How Should Your App Handle Slow Carrier Responses?
Handle slow carrier responses asynchronously, with webhooks, idempotency keys and outage patterns such as circuit breakers. Quote latency varies by carrier, from near-instant responses to referrals that take far longer. An app that waits on blocking calls will time out under load.
1. Webhooks beat polling for slow carrier responses
Accept the quote request, return 202 Accepted, and process the carrier call asynchronously. Webhooks then notify your app when the carrier finishes. Verify each webhook signature before acting on it, so a spoofed event cannot bind or cancel a policy.
Polling works as a fallback when a carrier offers no webhooks, at the cost of extra calls. Poll with growing intervals and a hard timeout so a stuck quote does not loop forever. Typical webhook events include:
- quote.completed: a carrier has returned a premium.
- quote.declined: a carrier has refused to offer terms.
- policy.bound: a carrier has confirmed an active policy.
- document.ready: policy documents are available to download.
- claim.updated: a claim has changed status at the carrier.
2. Idempotency keys matter most on bind and payment calls
Idempotency keys stop a retried request from creating a duplicate record. Attach one to every bind and payment call. Generate the key once per user action and reuse it on every retry of that action.
A timeout followed by a retry must never bind two policies or charge a card twice. Store each key with its first response, so a repeat request returns the original result instead of running again.
3. Outage patterns turn carrier failures into delays
Carrier outages are routine, so the app needs patterns that contain them. Each pattern handles a different failure, from a brief blip to a carrier that stays down for hours.
- Retries with exponential backoff: space out repeat attempts so a struggling carrier can recover. Add jitter so retries from many users do not hit the carrier at the same moment.
- Circuit breaker: stops calls to a failing carrier while others keep quoting. After a cooldown, a few test calls decide whether to reopen traffic.
- Dead letter queue: holds failed messages for review instead of dropping them. Your team can replay them once the carrier recovers.
With all three in place, a carrier outage costs time rather than policies. Proving these patterns work is the job of testing.
How Do You Test and Certify a Carrier Integration?

Sandbox testing proves your logic, but the carrier decides when you reach production. Plan for both gates from the start. Both gates affect how long it takes to develop an insurance app, so build certification and retest windows into the plan.
- Build against each carrier’s sandbox, or a mock where no sandbox exists. Keep sandbox credentials and endpoints separate from production config. Seed the mock with real response samples, including errors, so it behaves like the live carrier.
- Run contract tests that fail the moment a carrier changes a field. Run them on a schedule, not only when your own code changes. A nightly run against each sandbox catches silent schema drift before customers do.
- Test failure paths: timeouts, declines, duplicate binds and malformed payloads. Simulate each one in staging before a carrier sees real traffic. Confirm the app shows a clear message and logs the event instead of failing silently.
- Complete the carrier’s user acceptance testing with its technical team. Expect scripted scenarios that cover quoting, binding and servicing. Keep test policies, IDs and screenshots on hand so carrier testers can trace each result.
- Pass the certification call or sign-off the carrier requires before go-live. Plan for retest time if the carrier finds gaps. Once live, monitor the first production quotes and binds closely before scaling traffic.
Testing shows your app is ready, and certification shows the carrier agrees. Reaching certification depends on winning access in the first place.
How Do You Actually Get Carrier API Access?

Most carriers do not publish open production APIs. Access follows a business relationship, and that relationship has gates.
1. Carriers clear you commercially and technically first
Expect five gates before a carrier allows any production call:
- Business case: a distribution plan the carrier’s underwriting team accepts. Target customer segments and projected premium volume usually anchor that plan.
- Partnership or appointment: a partner program agreement or a direct appointment with the carrier. The agreement sets which products you can sell and how commissions are paid.
- Licensing: any producer licenses your distribution model needs in the states or provinces where you sell. Selling across several states or provinces can mean a license in each one.
- Network controls: IP allowlisting and mTLS configured against the carrier’s endpoints. Share static IPs and certificates early so network setup does not delay testing.
- Certification: UAT completion and sign-off from the carrier’s technical partnership team. Sign-off usually covers both functional results and security review findings.
2. An aggregator or custom layer can shorten the path
An aggregator can shorten access for carriers inside its network, because that relationship already exists. Carriers outside the network still need their own agreement. Check the aggregator’s carrier list against your target carriers before you sign.
A custom layer does not replace carrier agreements. Instead, each newly approved carrier becomes one adapter rather than a rebuild, which shortens the engineering side. Business approvals still move at each carrier’s pace.
Plan Your Carrier Integration Before You Write Any Code
Share your insurance line, target carriers or aggregator, and tech stack. We will map access requirements, compliance scope, cost and timeline in a free consultation.
Access is a business process first and an engineering task second. Space-O Canada plans the engineering track around your carrier agreements, starting in discovery. Teams that need more capacity can also hire insurance app developers to run that track alongside in-house staff.
How Does Space-O Canada Help With Insurance Carrier API Integration?
Space-O Canada helps insurers and fintech startups plan, build and support carrier API integrations, from path selection to certification sign-off. Discovery fixes the carrier list, compliance scope and canonical data model first. The same insurance and fintech engineers then build the adapters, security controls and resilience patterns on top of that plan.
Because the team builds for both US and Canadian markets, one platform can serve carriers on both sides of the border, with GLBA, NAIC and PIPEDA duties mapped side by side. After launch, the team can add carriers, update adapters when carrier APIs change and extend the app into new lines of business.
Every project includes up to 90 days of free post-launch support. For budget planning, see the full breakdown of the cost to build an insurance app.
Settling the path, data model and carrier access early keeps a carrier integration on schedule, and a few questions still come up before work starts.
Frequently Asked Questions About Integrating Carrier APIs
How do APIs work in a carrier integration?
Your app sends a request to a carrier endpoint, and the carrier returns a response. When a carrier is slow, your app returns 202 Accepted and finishes the carrier call asynchronously. Webhook events such as quote.completed then tell your app the work is done.
How does an API gateway help modernize legacy insurance systems?
An API gateway puts one modern entry point in front of legacy insurance systems and enforces authentication, rate limits and logging on every carrier call. Behind the gateway, per-carrier adapters convert SOAP/XML and REST/JSON into one internal model. Legacy systems can then be modernized in phases without changing how the app calls them.
What should be settled before writing any carrier integration code?
Settle the carrier list, compliance scope and canonical data model first. Then plan carrier access early, since carriers may require a business case, licensing and certification. Fixing these in discovery avoids rework. The insurance app development guide covers the wider build beyond carrier APIs.
How do I start testing if a carrier has no sandbox?
Build against a mock of the carrier’s API and write contract tests that fail when a field changes. Also test timeouts, declines and duplicate binds. Carrier UAT and certification sign-off are still required before go-live.
How do I handle a carrier changing its API after launch?
Contract tests fail the moment a carrier changes a field, which flags the change early. Update only that carrier’s adapter to map the new fields. Version the schema so other carriers stay unaffected.
How do I add a new carrier after launch?
Secure the carrier’s agreement or appointment first, then build one adapter mapping its fields to your canonical schema. Configure network controls such as IP allowlisting and mTLS. Finish with sandbox testing, UAT and certification sign-off.
Let’s Discuss Your Idea
Share your idea with our fintech development team and get a practical breakdown of what you need to build, integrate, secure, and launch it.
What our clients say






