Product that suits modern B2B Tech companies

Book Demo
B
Book demo call-to-action illustration
BACK
B

API aggregators explained: unified API or gateway aggregation?

Platform APIs
November 27, 2025
Summarise the blog with AI
Open in ChatGPT
Ask questions about this page
Open in Claude
Ask questions about this page

Last verified: 2026-11-17

Key takeaways

  • "API aggregator" names two different architectures: a unified API over your customers' third-party systems, and gateway aggregation over your own backend services.
  • Which one you are looking at depends on whose APIs are being combined, whatever the vendor's wording.
  • A sync-based unified API answers reads from a stored, normalized copy, so one interface does not mean one live call to every provider.
  • Gateway aggregation fans one request out to several services; keep light composition in the gateway and move domain logic to a dedicated aggregation service behind it.
  • Test any unified API on freshness interval, per-account rate limit, per-integration model coverage and the path to unmapped fields.

"API aggregator" reads like one product category. It's two.

An API aggregator gives software one interface to many APIs, and the term names two different architectures. A unified API normalizes many third-party providers in one category into one data model, and it typically works from data synced on a schedule. Gateway aggregation fans one client request out to several backend services and combines the responses. The first saves you from building and maintaining integrations; the second saves the client round trips. In both, freshness and coverage depend on the aggregator.

One combines your customers' systems; the other combines your own services. One typically serves a stored copy; the other invokes backends as requests arrive. Evaluate the wrong one with the wrong questions and you end up comparing connector counts for a pattern that has no connectors, or counting round trips for a problem that is really about stale data.

Which kind of API aggregator are you looking at?

Ask whose APIs are being combined. If they're your own backend services, it's gateway aggregation. If they belong to software your customers run, you're looking at a unified API or at integrations you build yourself, and scope separates those two: a unified API fits many customer systems in one category, while direct builds fit one or two deep integrations. Direct builds are the baseline both aggregation kinds are measured against.

Approach Whose APIs it combines What one call does Where response data comes from Who handles authorization What you still build Fits when
Unified API Third-party systems your customers use, within one category Reads or writes one normalized data model A normalized copy, typically synced on a schedule; freshness varies by provider Your customer, in a hosted flow the aggregator provides Product logic on the shared model, plus handling for fields it lacks Many customer systems in one category
Gateway aggregation Your own backend services Fans one request out to several services and combines the replies The backend services, invoked as the request is handled Your platform's own authentication The backend services and the composition logic One client screen needs data from several of your services
In-house direct integrations Each external system's API, one at a time Calls one provider's API in that provider's format That provider's API, through your own code Your product, per provider Every connector: authorization, mapping, maintenance You need one or two deep integrations

This page uses "unified API" for the first row and "gateway aggregation" for the second. If a vendor says "universal API" or just "aggregator", test the claim against the first row. Once you've settled on the unified kind, the next distinction is how it differs from an embedded iPaaS, which unified API vs embedded iPaaS covers.

The column that decides the most is "where response data comes from". For a unified API, the answer is less obvious than the interface suggests.

How a unified API works, step by step

A unified API runs four steps between your app and a customer's system, and in a sync-based design, step three means reads come from data the aggregator has already pulled and mapped. The sequence, from first click to first read:

  1. Authorize: Your customer opens a hosted flow, launched from a link or embedded in your product, and grants access to their system.
  2. Exchange: The flow returns a short-lived grant (some flows call it a public token), and a server-side call trades it for lasting access.
  3. Sync and normalize: The aggregator pulls records from the customer's system, on a schedule or on demand, and maps each provider's fields onto one shared model.
  4. Read and notify: Your app reads the normalized data through one API, and webhooks report when connections link, syncs finish or something fails.

Say your product needs each customer's employee list. Whichever HRIS a customer runs, your app calls one endpoint and gets one shape. But in a sync-based design that call is answered from the copy built in step 3, not by reaching into the customer's HRIS. One interface is not one live request to every provider. Some designs fetch on demand instead, so ask which one you're getting.

In Bindbee's API, that one call looks like this. modified_after returns only records synced since the time you pass, so a scheduled read picks up what the last sync changed:

Request
curl -G https://api.bindbee.dev/api/hris/v1/employees \
  -H "Authorization: Bearer <BINDBEE_API_KEY>" \
  -H "X-Connector-Token: <CONNECTOR_TOKEN>" \
  -d modified_after=2026-11-01T00:00:00Z

The access method behind step 1 matters too. The CFPB's 2024 Personal Financial Data Rights rule separates two ways third parties get account data. In credential-based screen scraping, the consumer shares login credentials with the third party. With a developer interface, the data provider maintains access for third parties. The rule covers US consumer financial data, but the distinction is worth asking about for any aggregator.

Because step 1 is the part your customers see, who hosts it is a design decision. Bindbee offers a hosted Magic Link or an Embedded SDK inside your product, and the end customer's credentials never pass through your product.

After step 3, Bindbee's webhooks notify you when a connector links, syncs, fails or needs relinking, and when a sync creates or updates records. They follow each sync; they are not instant-change events. For what one connector does inside step 3, see how API connectors work.

So far, every system being combined has belonged to your customers. Point the same idea at your own backend and you get the other meaning of the word.

How gateway aggregation works, and where the logic belongs

Gateway aggregation is a pattern in which an API gateway answers one client request by invoking several backend services and combining their results into one response. NIST SP 800-204 (2019) describes it this way: an API gateway often handles a request by invoking multiple microservices and aggregating the results.

Take a mobile account screen that shows a customer's profile, recent orders and open invoices, each owned by a different service. Without aggregation, the app makes three calls and stitches the results together. With it, the app sends one request, the gateway calls the three services, and one combined response comes back. The client saves round trips, and you take on a fan-out inside your own infrastructure.

Where the combining happens matters more than the pattern. Keep light composition in the gateway: merging three responses, renaming fields, dropping what the screen doesn't need. Move domain logic, multi-step orchestration or heavy transformation into a dedicated aggregation service behind the gateway. A gateway that starts deciding what counts as an overdue invoice has become a second application, and every client's requests now depend on it.

Wherever you place the aggregation, the component doing it needs four kinds of failure handling:

  • A timeout on every backend call, so one slow service can't hold the whole response.
  • A partial-response rule: if invoices time out, the screen still gets profile and orders, with invoices marked unavailable.
  • A circuit breaker, which NIST defines as a failure threshold per service instance, above which the proxy stops sending requests to that instance.
  • Redundancy and scaling for the gateway itself, because every aggregated request now depends on it.

The first three contain one backend's failure. The fourth covers the gateway's own, and it's the single point of failure this pattern creates.

Nothing here involves your customers' systems, a sync or a shared data model. Read the benefits that follow per kind.

What each kind buys you, and the condition attached

Every benefit of an aggregator is real and conditional, and the condition is where an evaluation should start. A unified API buys five things:

  • One build for many providers, as long as they sit in one category and you accept the shared model.
  • Consistent data across providers, but only for the fields the model maps.
  • Less connector maintenance for your team, because upkeep of each connector shifts to the vendor.
  • Customer-authorized connections, arriving through a hosted flow instead of credentials your team collects.
  • Writes back to the source system, where the integration supports them.

Gateway aggregation buys two:

  • Fewer client round trips, as long as the client needs data from several services at once.
  • One place for cross-cutting concerns, provided the gateway stays thin enough that business rules don't pile up in it.

As a concrete reference point for the first list, Bindbee connects to 110+ HRIS, payroll, ATS and benefits systems through one API, with 40+ unified data models across HRIS, payroll, ATS, LMS and benefits. Reads and writes go through the same API, and write support varies by model and integration. How many of those models work on a given system is a per-integration question, which the last section returns to.

To measure these benefits in engineering and product terms, see integration KPIs and benefits.

The unified API's conditions are where it can fail you. What happens when one isn't met?

What a unified API costs you

A unified API costs you in four places, and each is the other side of a benefit above: in a sync-based design, a stored copy that can be stale; a limit on each connection; fields the shared model doesn't carry; and one more vendor holding access to your customers' systems.

Limit Why it happens What to ask any provider How Bindbee handles it
Freshness In a sync-based design, reads come from a stored copy, so data is as current as the last sync Does it serve a stored copy or fetch on demand? What is the sync interval, and can you force a resync? A Production connector syncs every 24 hours by default, adjustable per connection on request. Reads return the copy from the last completed sync. Resync can be forced through the API.
Rate limits Limits can attach to each connected account (some providers say linked account), so bulk work for one customer runs against that customer's limit What is the per-account limit, and can it be raised? 200 requests per minute per connector. Custom limits for enterprise on request.
Fields the shared model lacks The shared model exposes only the fields it maps Can you reach an unmapped field through the raw payload, a field mapping or passthrough? Upstream payload returned alongside each record with include_raw_data=true; Custom Fields map a field from it via JMESPath; Passthrough to the source system's API.
Dependency and security The aggregator holds an access token for every connected account, and its responses are third-party data What certifications and encryption does it carry, and what happens to your product if it is unavailable? SOC 2 Type II compliant. Encrypted in transit (TLS 1.3) and at rest (AES-256), per Bindbee's published security FAQ.

Take freshness. A customer terminates an employee in their HRIS at 9:05, and your product reads that employee at 9:30. A sync-based unified API serves the stored copy, so the employee still shows as active until the next sync completes. In Bindbee, that gap is set by a sync interval of 24 hours by default. Webhooks follow each sync, so they tell you the new copy has landed rather than that something changed upstream the moment it did.

Bindbee's writes have the mirror-image quirk. A write goes straight to the source system, but you can read it back only after the next sync.

Rate limits change how you plan bulk work. Bindbee limits each connector to 200 requests per minute, so one customer's traffic can't exhaust another's. What other providers call a linked account is a connector here, so a backfill against one customer's connector runs at that connection's rate however many customers you have.

Fields the model doesn't map are the third cost: consistent data holds only for mapped fields, so the rest has to be reached another way. Bindbee gives three ways, ordered by how far they sit from the model:

  • The upstream payload, returned alongside each record as raw_data when you request it with include_raw_data=true. Use it to find the field.
  • A Custom Fields mapping that surfaces that field on a unified model through JMESPath, per integration or per connector.
  • Passthrough, which forwards a raw request to the source system's own API using the connector's existing credentials, for a field the payload doesn't carry.

The first one looks like this, trimmed to one record:

Request
curl -G https://api.bindbee.dev/api/hris/v1/employees \
  -H "Authorization: Bearer <BINDBEE_API_KEY>" \
  -H "X-Connector-Token: <CONNECTOR_TOKEN>" \
  -d include_raw_data=true
Response
{
  "items": [
    {
      "first_name": "Jane",
      "employment_status": "ACTIVE",
      "raw_data": {
        "firstName": "Jane",
        "employmentStatus": "Active",
        "customFields": { "badgeId": "B-4417" }
      }
    }
  ]
}

Active became ACTIVE in the unified field, and badgeId has no unified equivalent, so it's the value a Custom Fields mapping would surface.

A passthrough call is shaped by the source system rather than the model, which is the price of leaving it. The custom fields, raw data and passthrough guide covers all three in depth.

Last is concentration. One vendor now sits in front of every connected system and holds an access token for each, so test what it holds and how it protects it. Then test what you do with what comes back: the responses are third-party data, so validate them before your product acts on them. Whether your product keeps working when the aggregator is unavailable is a question to ask, not one to assume.

Which one you need, and what to check before you adopt it

Start with whose APIs you're combining. Your own services point to the first branch below. Customer systems point to the other two, and how many systems you need and how deep each integration goes decides between them:

  • Gateway aggregation fits when a client needs data from several of your own services.
  • A unified API fits when your product has to read from, and write to, many customer systems in one category.
  • Direct builds fit when you need one or two deep integrations.

If you land on a unified API, run this checklist before you sign:

  • Per-integration model coverage for every system your customers use, not the total connector count.
  • The connection method for each system: its own API or a file export, and whether anything relies on screen scraping.
  • What the bill counts (connected accounts, API calls, records or syncs) and what your volume does to it.
  • The four limits from the last section: sync interval, per-account rate limit, path to unmapped fields and security posture.

A connector count tells you which systems; it doesn't tell you which models work on them. Bindbee publishes per-integration model support in a Model Availability Matrix, with each model marked Available, Beta or not available. It connects through each system's own API (OAuth, API key, token or certificate) or a customer-run SFTP export, never screen scraping. Pricing is per connected customer, with every integration included and syncs unmetered.

If you need one or two deep integrations, building in-house or outsourcing is the branch to read. To compare unified APIs with iPaaS and embedded platforms, see the top API integration companies for 2026. Bindbee's models span HRIS, payroll, ATS, LMS and benefits, so check your category first; the HR and payroll buyer's guide has the full evaluation.

An aggregator's convenience comes from what it keeps between you and the systems it combines: a normalized copy in one case, a composition layer in the other. That is also where its limits sit. Know which kind you're buying, then ask about the thing in the middle.

We build the integrations. You build the product. To see whether the systems your customers use are covered, check the Bindbee integrations list.

FAQ

Is a unified API real-time?

Usually not. A sync-based unified API serves reads from a stored copy, so data is as current as the last completed sync. Bindbee syncs each Production connector every 24 hours by default, adjustable per connection on request, and you can force a resync through the API when you need fresher data. Webhooks tell you when a sync has landed.

What happens when a field isn't in the unified model?

You reach it another way. With Bindbee, request the upstream payload with include_raw_data=true to find the field, map it onto the unified model with a Custom Fields JMESPath expression, or call the source system directly through Passthrough when the payload doesn't carry it.

Who holds my customers' credentials?

With a hosted authorization flow, the aggregator does, not your product. With Bindbee, your customer authorizes through a hosted Magic Link or the Embedded SDK, and their credentials never pass through your product. Ask any vendor where it stores them and how they are protected.

Is it safe to connect an account through an API aggregator?

Safety depends mainly on the access method: a hosted, token-based developer interface keeps your credentials with you, while handing credentials to a third party does not. In the US, the 2024 CFPB rule that would require developer interfaces is under CFPB reconsideration, and a federal court in Kentucky has enjoined enforcement. A revised proposal went to OIRA in August 2026 and had not been published as of 2026-11-17.

Book a demo with Bindbee
Kunal Tyagi
CTO
Bindbee
VIEW AUTHOR
BLOG_

Related blogs