Skip to Main Content

API Security Mesh: Zero Trust Security Without Fragmenting Integrations

API Security Mesh: Seguridad Zero-Trust sin fragmentar integraciones
Publication date: November 18, 2026

Zero Trust security for APIs starts with a simple principle: no request should be trusted merely because it comes from an internal network, a familiar system or a particular location.

Every access attempt should be assessed based on the identity of the user or workload, the requested resource, the intended action and the context.

In hybrid architectures, that verification cannot always rely on a single perimeter gateway.

An API Security Mesh extends this approach by distributing enforcement across different points in the architecture:

  • API gateways at the edge,
  • proxies or ztunnels for east-west traffic, and
  • inline gateways in front of selected legacy systems.

Standards and technologies such as SPIFFE/SPIRE, mTLS, Open Policy Agent, OpenTelemetry and DPoP can all be part of this model without forcing the entire organisation onto a single technology stack.

In this guide, we explore:

  • how to apply Zero Trust security to an API architecture without disrupting existing integrations,
  • how to distribute controls across cloud and legacy environments,
  • how to manage workload and AI agent identities, and
  • what governance model can prevent new single points of failure and excessive vendor dependence.

 

What Does Zero Trust Security Mean for APIs?

Zero Trust shifts the focus away from the network perimeter and towards resources, identities and access decisions.

NIST SP 800-207 defines Zero Trust as an approach in which no implicit trust is granted solely on the basis of a user’s or asset’s physical or network location.

Authentication and authorisation must take place before access to a resource is established.

For APIs, this means that being “inside the corporate network” is not enough to make an API call secure.

At a minimum, every request should be able to answer questions such as:

  • Who is making the call?
  • Which workload or application is behind it?
  • On whose behalf is it acting?
  • Which resource does it want to access?
  • What operation is it trying to perform?
  • How risky is this access right now?

The API gateway remains an important part of enforcing these controls, but it is no longer necessarily the only place where trust is established.

NIST SP 800-228, updated in March 2026, organises API security risks and safeguards across development, pre-runtime and runtime phases, and recommends an incremental, risk-based approach.

 

For a broader overview, explore Chakray’s API Security and Integration capabilities.

 

From a Centralised Gateway to an API Security Mesh: What Changes?

A centralised API gateway can authenticate consumers, validate tokens, enforce rate limits, transform requests and protect backend services.

That does not mean a gateway-centric architecture is inherently wrong, or that a central gateway automatically creates a single point of failure (SPOF).

The problem arises when the entire security model depends on one enforcement point, or when significant traffic never passes through it.

An enterprise architecture may include all of the following:

  • public APIs,
  • microservices communicating directly with one another,
  • Kubernetes workloads,
  • multiple cloud environments,
  • application-to-application integrations,
  • M2M agents and automations,
  • ERPs and long-established applications,
  • on-premises legacy APIs.

A perimeter gateway may be highly effective at controlling north-south traffic, but it does not necessarily see every east-west communication or traffic within legacy domains.

NIST SP 800-207A addresses this issue in cloud-native, hybrid and multicloud architectures.

Its model combines API gateways, sidecar proxies and application identity infrastructures such as SPIFFE to enforce identity-based policies regardless of where a service is deployed.

An API Security Mesh should therefore not be understood as “replacing the gateway with a mesh”.

The right approach is to distribute enforcement to the points where access actually takes place.

 

API Security Mesh: Zero Trust security without fragmenting integrations

 

Distributing Zero Trust Security Across the Edge, Service Mesh and Legacy Systems

The goal is to place each control close to the traffic it needs to protect while maintaining consistent governance.

Edge: Protecting North-South Traffic

The API gateway remains the natural enforcement point for:

  • external applications,
  • partners,
  • customers,
  • mobile applications,
  • public APIs,
  • certain agents and automations.

At this layer, controls may include OAuth 2.0, OpenID Connect, mTLS, token validation, rate limiting, abuse prevention and API-specific safeguards.

In some OAuth scenarios, DPoP (Demonstrating Proof of Possession), defined in RFC 9449, can also be used.

DPoP binds OAuth 2.0 tokens to a cryptographic key controlled by the client, making it harder for an attacker who obtains only the token to reuse it from another client.

For server-to-server traffic within the mesh, RFC 8705 allows a token to be bound to an existing client certificate, reusing available cryptographic material rather than introducing a second proof-of-possession mechanism.

East-West: Workload Identity Matters More Than Network Location

In microservices, Kubernetes and multicloud architectures, assuming a service is trustworthy simply because it belongs to a particular subnet recreates the very trust model that Zero Trust is designed to eliminate.

Workload identity and service mesh mechanisms can authenticate services and secure east-west communications.

SPIFFE defines a standard for assigning identities to workloads across heterogeneous environments.

A workload can use a SPIFFE Verifiable Identity Document (SVID) to prove its identity cryptographically. X.509-SVIDs can also establish authenticated TLS channels between services.

mTLS and SPIFFE tell you who is calling; they do not tell you on whose behalf the call is made or which object it is allowed to access.

A perfectly authenticated channel can still carry a completely unauthorised operation.

Policies built on that identity can answer questions such as:

  • Can this service call this endpoint?
  • From which environment?
  • For which tenant?
  • With what permissions?
  • For what type of information?

The underlying mechanism may be a traditional sidecar or an ambient model. The distinction matters: in ambient mode, the L4 component (ztunnel) establishes mTLS and authorises by identity, port and protocol, while layer 7 policies (method, path or header) require a waypoint proxy.

A rule such as “this service may read orders but not modify them” is an L7 decision and requires an enforcement point that understands the request.

Zero Trust does not require any particular service mesh implementation.

Legacy: Adding Protection Without Making Everything Cloud-Native

An older ERP, industrial application, SOAP system or mainframe may not support sidecars, automatic certificate rotation or additional cryptographic overhead.

The solution should not be to force a system to adopt capabilities it was never designed to support.

Instead, an inline gateway or proxy can be placed in front of the legacy domain.

That component can:

  • terminate TLS,
  • validate identities,
  • translate credentials,
  • enforce rate limits,
  • control concurrency,
  • validate messages,
  • implement circuit breaking,
  • decouple selected operations through asynchronous mechanisms.

An inline proxy only provides meaningful protection if it is the sole network path to the protected system. If the backend can still be reached directly from the corporate network, the control exists on paper only.

Distributed enforcement requires alternative routes to be closed at every layer through segmentation, restricting the backend to proxy-only connections and denying everything else by default.

 

You might also like: API wrappers in legacy systems for licensing cost control

 

Zero Trust Identity for Workloads and AI Agents

The spread of agents, copilots and automated processes is multiplying the number of non-human actors capable of consuming APIs.

A shared API key or generic service account is no longer enough when different agents can retrieve information, trigger processes or modify enterprise systems.

The architecture should distinguish at least three dimensions: workload identity → delegated authority → requested action.

SPIFFE can help prove which workload is establishing a connection.

OAuth, OIDC and other authorisation mechanisms can represent the authority granted by a user or system.

Policy must then determine whether that identity can perform that specific operation on that specific resource at that particular moment.

For example, an agent authorised to check an order’s status should not automatically gain permission to change suppliers, update bank details or make a payment.

The link between the two identities is formalised through token exchange (RFC 8693): the workload authenticates using its SVID and receives a token whose act claim identifies on whose behalf it is acting.

The resulting authority must be narrowed monotonically—never expanded—relative to the delegating user’s permissions.

Without that chain of delegation, a legitimate workload can become a confused deputy: correctly authenticated, but carrying out an action its delegator was not entitled to request.

An identity should not remain active indefinitely. Its lifecycle should cover:

  • provisioning,
  • short-lived credentials,
  • rotation,
  • permission changes,
  • revocation,
  • decommissioning.

Shorter credential lifetimes shift the risk: rotation failures and clock skew become availability incidents, and they need to be accounted for before production.

 

Read next: Agentic Enterprise Architecture: How to Govern Autonomous Integrations Without Restricting Autonomy

 

Context-Aware Zero Trust Policies: Govern Centrally, Enforce Close to the Traffic

A policy based solely on “valid token = access granted” is not enough for a complex Zero Trust architecture. This is the underlying problem behind API1 (BOLA) and API5 (BFLA) in the OWASP API Security Top 10 2023: deciding which specific object and function can be accessed is not the same as validating a token.

A decision may depend on several factors at once:

  • identity,
  • tenant,
  • action,
  • resource,
  • data sensitivity,
  • environment,
  • workload security posture,
  • risk,
  • recent behaviour,
  • backend status.

Policy-as-Code engines such as Open Policy Agent can help separate these rules from individual application logic.

But the architectural pattern matters more than the tool.

The risk is that every API gateway, team, sidecar or application ends up implementing its own interpretation of corporate policy.

That is why it helps to separate two responsibilities:

  • Policy Decision Point (PDP): decides what should be allowed.
  • Policy Enforcement Point (PEP): enforces that decision close to the traffic.

Not every request should require a remote call to the PDP.

When there are multiple PEPs, validating the intended audience is essential. A token issued for one API should not be accepted by another:

  • RFC 8707 allows the requested resource to be scoped when obtaining a token, and
  • RFC 9068 standardises the claims each PEP must verify, helping prevent inconsistent token checks across enforcement points.

Depending on the risk, PEPs may use:

  • distributed policies,
  • controlled caching,
  • TTLs, and
  • revocation mechanisms.

In every case, they must be able to keep services running through bounded interruptions.

A degradation strategy must be defined in advance. It should establish a maximum acceptable policy age for each route and recognise that revocation is the first capability compromised by caching.

An outage in the control plane must not automatically result in unrestricted access.

API Security Mesh: Zero Trust security without fragmenting integrations

 

Shadow APIs: Discovery Alone Is Not Enough

A Zero Trust model can hardly protect assets it does not know exist.

Shadow APIs are particularly problematic in organisations with years of accumulated integrations, acquisitions, departmental development and legacy applications.

An API may remain operational even though it is missing from the corporate catalogue, has no clear owner or was created by a team that no longer exists.

Discovery can draw on network traffic, gateways, repositories, cloud configurations, service mesh data, telemetry and observability.

No single source provides the full picture. The biggest blind spot is legacy east-west traffic: it appears neither in a gateway’s logs nor in a mesh the system does not belong to.

But discovering an API is not the same as governing it.

Every identified asset raises questions: Who owns it? What data does it expose? Who consumes it? Should it be retained, secured, modernised or retired?

This is where API Security Mesh needs to connect with API Governance, the mesh broadens visibility and enforcement, while governance establishes who is accountable for what is discovered and under which rules.

 

Don’t miss: How to Control API Sprawl in AI-Amplified Environments

 

How to Avoid Creating New Single Points of Failure

Distributing PEPs does not automatically make the architecture more resilient.

An organisation can move from one central gateway to twenty enforcement points and still depend on a single component whose failure brings every decision to a halt.

The key is to separate the control plane from the data plane properly.

PEPs should be able to continue enforcing valid policies during controlled interruptions to the decision plane, with suitable redundancy and clearly defined blast-radius limits:

  • cached policies where appropriate,
  • defined expiry periods,
  • revocation mechanisms,
  • risk-based degradation behaviour.

Behaviour should vary according to criticality.

A sensitive financial transaction may require a fail-closed approach if authorisation cannot be verified.

A low-risk read request might tolerate a limited, temporary fallback policy, provided it has been explicitly designed.

There is no universal rule.

 

Observability Is Part of Zero Trust Security Too

With multiple enforcement points, the challenge is not just applying policy but being able to reconstruct what happened.

A useful security trace should correlate: identity → policy → decision → PEP → API → backend → outcome.

If the edge records one identity, the mesh another and the legacy gateway a third, with no correlation IDs, the architecture has distributed not only controls but also the evidence.

Observability capabilities bring together logs, metrics and traces from those components to detect errors, unusual denials, added latency and unexpected access patterns.

 

Explore our Observability and API Monitoring capabilities

 

Beyond Deploying Tools: Governing the Transition

One of the main risks of a Zero Trust initiative is replacing one technology dependency with another.

For example:

  • Before: every policy depends on the gateway.
  • After: every policy depends on a particular service mesh platform.

The architecture has changed technically, but the organisational problem may be exactly the same.

An enterprise transition needs to define who owns each layer, who can change policies, how systems are prioritised, what criteria must be met before moving to the next phase and who approves exceptions:

  • what documentation must be retained,
  • how knowledge is transferred,
  • how to switch providers if necessary.

The technical answer often explains which components to deploy, but not how to govern a transition across teams, suppliers, legacy systems and security domains.

 

Dimension Tactical approach Governed approach
Gateway → mesh Deploy proxies and policies Define phases, owners and exit criteria
Machine identity Issue certificates or tokens Manage lifecycle, ownership and revocation
Shadow APIs Detect endpoints Assign an owner and decide on remediation
Resilience Add replicas Define dependencies, degradation and blast radius
Audit Store logs by component Correlate decisions and execution across layers
Vendor lock-in Adopt a platform Design portability and an exit strategy

 

At Chakray, we approach these projects through Governance and Delivery Management: architecture, migration sequence, acceptance criteria and ownership are documented and do not depend on the provider implementing each phase.

 

How to Implement an API Security Mesh in Phases

A Zero Trust security rollout should not begin by deploying new gateways, a service mesh, workload identity and Policy-as-Code across the entire organisation at once.

The approach should be incremental and risk-based, in line with NIST SP 800-228’s recommendations for API protection.

1. Discover the True Scope

Inventory:

  • APIs,
  • workloads,
  • consumers,
  • agents,
  • legacy systems,
  • sensitive data,
  • critical routes,
  • shadow APIs.

2. Establish an Identity Model

Define how to identify:

  • people,
  • applications,
  • workloads,
  • agents,
  • service accounts.

Rotation, revocation and ownership must also be defined.

3. Strengthen the Edge

Review authentication, authorisation, validation, rate limiting, resilience and availability for north-south traffic.

4. Extend Enforcement to East-West Traffic

Start with the highest-risk services or those that most need controlled service-to-service communication.

There is no need to bring the entire environment into the mesh at the same time.

5. Protect Legacy Domains

Identify which systems need an inline layer and which can remain under existing controls.

The goal is to reduce risk without triggering unnecessary modernisation.

6. Unify Policies and Evidence

Standardise:

  • identity,
  • decisions,
  • policies,
  • traceability,
  • correlation.

The aim is to prevent multiple PEPs from creating multiple conflicting versions of the truth.

7. Test Failures and Degradation

Simulate:

  • PDP failure,
  • loss of connectivity,
  • policy expiry,
  • gateway outages,
  • overload,
  • identity revocation.

Zero Trust resilience must be tested, not assumed.

8. Formalise the Operating Model

Complete the transition with:

  • runbooks,
  • clear ownership,
  • training,
  • architecture documentation,
  • change management processes,
  • vendor exit criteria.

 

NIS2, DORA and PCI DSS: What the Architecture Needs to Deliver

An API Security Mesh does not automatically make an organisation compliant.

What it can provide is a more consistent technical foundation for demonstrating which identity accessed which resource, under which policy, what decision was made and where it was enforced.

Under NIS2, the reporting process for significant incidents includes:

  1. an early warning within 24 hours,
  2. an incident notification within 72 hours, and
  3. a final report, generally within one month of the notification.

For financial entities subject to DORA, Commission Delegated Regulation (EU) 2025/301 states that the initial notification of a major ICT-related incident must be submitted as soon as possible and, in any event, within four hours of classifying it as a major ICT-related incident and no later than 24 hours after becoming aware of it.

The intermediate report must generally be submitted within 72 hours of the initial notification. The final report must be submitted within one month of the preceding report (or its latest update).

PCI DSS introduces a different requirement: controlling non-human identities.

Under version 4.0.1:

  • requirement 8.6.1 requires every action performed through a system or application account to be attributable to an individual user,
  • requirement 8.6.2 prohibits credentials embedded in scripts, configuration files or source code,
  • requirement 8.6.3 requires those credentials to be rotated and protected against misuse,
  • requirement 6.4.2 also calls for an automated technical solution at the edge to detect and prevent web attacks in front of public-facing applications.

These requirements align closely with the machine identity and north-south enforcement model described above.

This does not mean that DORA, NIS2 or PCI DSS mandate an API Security Mesh architecture.

It means a distributed architecture must produce correlatable evidence if an organisation wants to investigate and report incidents quickly.

The specific requirements of PCI DSS, DORA, NIS2 and any other regulations must be mapped to the sector, scope and systems concerned.

 

How to Reduce Vendor Lock-In

A vendor-neutral architecture does not mean every tool can be replaced at no cost.

It means avoiding a security model that depends entirely on a single vendor’s proprietary primitives.

Several mechanisms can help:

  • SPIFFE to standardise workload identity,
  • X.509 and mTLS as interoperable transport authentication mechanisms,
  • OpenTelemetry to standardise parts of the telemetry,
  • Policy-as-Code to separate selected rules from application logic.

But switching service meshes, API gateways or policy engines will still involve work.

That is why an exit strategy should define in advance which policies are portable, which configurations are not, how the inventory can be exported and which tests demonstrate equivalence.

The exit strategy belongs in the design, not at the end of the contract.

 

How Can You Tell Whether the Architecture Is Working?

Success should not be measured by the number of gateways, sidecars or policies deployed.

Metrics should show whether risk is falling without unnecessarily disrupting operations.

Relevant indicators include:

  • added latency per enforcement layer, measured at p95 and p99 for each hop,
  • PEP availability,
  • policy propagation time,
  • denial rates by reason,
  • authentication failures,
  • identity rotation failures,
  • discovered APIs without an owner,
  • authorisation incidents.

An architecture with more controls but less clarity may be harder to operate and audit than the one it was intended to replace.

 

Does Every Organisation Need an API Security Mesh?

No.

If an organisation has only a few APIs, all traffic passes through a well-governed API Management platform and there is little east-west, multicloud or legacy complexity, adding a service mesh and multiple PEPs may cost more than it delivers.

The pattern becomes valuable when the real trust boundaries no longer align with the API gateway perimeter—for example, with multiple clouds, directly connected microservices, AI agents or APIs that bypass the edge.

Zero Trust is not about deploying as many components as possible.

It is about preventing trust from being granted simply because something is inside the architecture.

Moving towards distributed Zero Trust security affects API Management, identity, integration, observability, security and enterprise architecture at the same time.

At Chakray, we can help you assess your current architecture, identify security gaps, design the target model and lead a phased transition that preserves existing integrations while reducing dependence on hard-to-reverse technology decisions. Talk to our experts and tell us about your environment.

 

Frequently Asked Questions About Zero Trust Security and API Security Mesh

What Does Zero Trust Security Mean for APIs?

Zero Trust security for APIs removes implicit trust based solely on network location.

Every access attempt must be authenticated and authorised with identity, resource, operation and context in mind.

What Is an API Security Mesh?

In this article, we use API Security Mesh to describe an architectural pattern—not a formal NIST standard—in which security enforcement is distributed across points such as API gateways, service meshes and inline gateways, while policies, identity and observability are governed consistently.

Does a Service Mesh Replace the API Gateway?

No. They are usually complementary.

The API gateway typically protects north-south traffic and external consumers, while a service mesh can enforce identity and policies for east-west traffic between services.

How Can You Apply Zero Trust to Legacy Systems?

One option is to place an inline gateway or proxy in front of the legacy system to authenticate requests, translate identities, limit traffic and enforce policies without extensive changes to the original application.

How Are Workloads and AI Agents Identified?

Workloads can use cryptographic identities based on standards such as SPIFFE/SPIRE.

For AI agents, delegated authority must also be represented, with limits on which operations they can perform on each resource.

How Can You Avoid Vendor Lock-In in an API Security Mesh?

Separate identity, policy, telemetry and governance from their specific implementations, use open standards where appropriate and document from the outset what is portable and how a vendor switch would work.