OpenCAPIF Interconnection
Overview
3GPP Release 16 introduced CAPIF Interconnection to enable distributed deployments of CAPIF Core Functions (CCFs) and interactions among API providers/invokers of various domains. More specifically, this enhancement allowed multiple CCFs — either of the same or different trust domains — to seamlessly interact, discover services, and publish APIs with one another. At the same time, CAPIF Interconnection enables API invokers to utilize the service APIs from 3rd party API providers.
According to the specifications, CAPIF-6 or CAPIF-6e reference points have been defined to enable communication between two CCFs. Through those interfaces CCFs can:
- publish, retrieve, update and unpublish service APIs information
- discover service APIs
- obtain security information for the API invoker upon accessing the service API, and
- provide authorization for the API invoker prior to accessing the service API.
More information on CAPIF Interconnection can be found on the following Technical Specification documents:
- 3GPP TS 23.200
- 6.2.2 Functional model description to support CAPIF interconnection
- 8.25 Support for CAPIF interconnection
- 3GPP TS 33.122
- 5.3 Functional security model supporting interconnection
- 6.13 Security procedures for CAPIF interconnection
Specification Compliance and Extensions
Our approach balances strict adherence to 3GPP standards with pragmatic engineering solutions. Where the 3GPP specifications do not fully define implementation details, we have made informed design decisions that:
- Maintain backward compatibility with existing OpenCAPIF implementations
- Follow the architectural principles established by 3GPP
- Provide clear extension points for future standardization updates
- Ensure robust security and reliability across domain boundaries
Implementation Approach
OpenCAPIF implementation of interconnection adheres to the 3GPP specifications while addressing areas where the standards provide limited definition. We have adapted and extended the specification-defined interfaces to accommodate the specific architectural requirements of OpenCAPIF, ensuring compatibility with existing deployments while enabling cross-domain service discovery and invocation.
OCF Release 5 implements a functional version of CAPIF interconnection capability, including all the necessary steps described below.
Interconnection establishment and synchronization
Interconnection establishment is initiated by the CAPIF administrator of a local CCF (CCF-A), using the "/request" API, towards a peer CCF (CCF-B).
POST /helper/interconnection/request with { "dstProvDom": "CCF-B host:port" }
- If dstProvDom is already in interconnected → 409.
- CCF-A calls CCF-B: POST https://{dstProvDom}/helper/interconnection/establish over mTLS, sending CCF-A’s ccfId, domain, CA, and public key.
- CCF-B stores A in interconnected and replies with B’s own identity.
- CCF-A stores that reply, then runs sync (below).
CCF administrator (either A or B) can also tear down the connection between the two CCFs
DELETE /helper/interconnection/request/{peerCcfId}
- Peer DELETE /establish/{localCcfId}
- On success, drop services whose apf_id is the peer CCF, pull that CCF from pubApiPath.ccfIds, delete the interconnected row.
After establishing the interconnection, the CCFs have to synchronize the state of the shared APIs. This is managed via the "/sync" API.
POST /helper/interconnection/sync from CCF-A to CCF-B.
On "/sync", the receiving CCF:
- Looks up the caller in interconnected by dstProvDom (404 if missing).
-
Publishes (to the interconnected CCF) every local API that matches:
-
shareableInfo.isShareable == true
- peer domain in shareableInfo.capifProvDoms
- apf_id is not the peer CCF (no bounce-back)
- peer CCF not already in pubApiPath.ccfIds
POST https://{dstProvDom}/published-apis/v1/{srcProvDom}/service-apis.
- The payload sets shareableInfo.isShareable = false so the peer does not re-share.
- Records the peer in pubApiPath.ccfIds
When CCF-B answers, CCF-A does the same in the other direction.
CAPIF-related 3GPP standards have not yet defined exact procedures of CAPIF-6(e) interface. All the above API definition and flows are a proposed implementation of OpenCAPIF SDG contortium.

Discover
Discover API has no interconnection-specific logic. It only queries the local service_api_descriptions collection and returns matching APIs. shareableInfo, pubApiPath, and ccfId appear because they are part of the 3GPP ServiceAPIDescription schema, and Discover includes them in the response
Publish
When the interconnection capability is enabled in CCFs, the publish API flow (POST) includes the following:
- Normal duplicate / feature checks.
-
Read shareableInfo:
-
isShareable is false or missing → local publish only.
-
isShareable is true → take capifProvDoms.
-
For each domain, look up interconnected by dst_prov_dom. Unknown domain → skip. Known domain → POST the copy to that peer’s Publish API (same URL as sync, isShareable: false).
- If any peer fails → withdraw copies already accepted, do not store locally, return 500.
- On success, store locally and set pubApiPath.ccfIds to the peers that got a copy.
- If the caller’s apfId contains "CCF" (incoming from a peer), that CCF is also appended to the path.
- Cert/APF checks are skipped when the client CN is superadmin or starts with CCF. Interconnected publications have no local APF cert entry.

In case of a PUT / PATCH request:
Peers are aligned before the local write:
- domains removed from capifProvDoms → DELETE on those peers
- domains kept → PUT the new definition
- domains added → POST
- sharing turned off → unpublish from all previous domains
Peer copies are found by old apiName, because each peer assigns its own apiId. If any peer cannot be aligned, the local API is left unchanged.
In case of a DELETE request:
Unpublish from peers first, then delete locally. If a peer is unreachable, the local copy stays so the two CCFs do not drift.

Creation of Security Context
For Invokers and Providers belonging to a common CCF, the access to exposed APIs follow the same flows:
- Provider registers itself and publishes APIs to the CCF.
- Invoker onboards and discovers APIs to the CCF.
- Invoker requests creation of a security context for any of APIs discovered.
However, when Provider and Invoker belong to different CCFs, internally the flows change. The specific flows are explained below.
When Invoker requests creation of security context for an API published on interconnected CCF, then Invoker's CCF will request creation of security context from the Provider's CCF. This will trigger creation of Access Control Lists (ACLs) and some other related events.

On next section the flows involved on security method selection will be detailed.
Consume Provider's API
There are 3 different flows involved, depending on selSecurityMethod returned by Invoker's CCF:
- OAUTH: Access token will be used to access exposed API.
- PKI: Invoker must use its certificate to access exposed API.
- PSK: Invoker must derive the PSK key from the connection between invoker and CCF at context creation.
NOTE: PSK and PKI security methods imply Provider must implement AEF_security_API defined by 3GPP, because Invoker will begin the communication to exposed api by requesting POST to /check-authentication with body.
OAUTH
For OAUTH security method,
- Provider only needs the public key of its CCF (Provider's CCF).
- Invoker will request an access token to its CCF (Invoker's CCF).
- Invoker's CCF will request internally to Provider's CCF the access token to be forwarded to Invoker.
- Invoker reaches the exposed API by including access token inside Authorization header at request.

Summary:
In this scenario, Invoker's CCF acts as a gateway to forward request to Provider's CCF, because this token will be created by private certificate of Provider's CCF.
PKI
For PKI security method,
- Provider must implement AEF_Security_API, defined by 3GPP. The check-authentication endpoint must be requested from Invoker before initiating consumption of any exposed API, indicating api_invoker_id. body
- Provider will request security context of api_invoker_id to Provider's CCF, and Provider's CCF will request security context to Invoker's CCF and this security context will be forwarded to Provider, which includes the ca root to decode invoker's certificate.
- Provider will take authenticationInfo present at security_info array inside GET security context response and store it to be used later.
- Invoker reaches exposed API by including its own certificate.
- Provider validates invoker's certificate, and checks api_invoker_id at the Common Name (CN) field.

Summary:
In this scenario, Provider must implement AEF_Security_API in order to begin communication by reach check-authentication by Invoker previous start consuming Provider's API.
Provider will request on this initial step the Security Context involved to obtain CA to be used to validate Invoker's certificate.
PSK
For PSK security method,
- Invoker derives PSK when requests creation of Security Context and stores it to be used later.
- Provider must implement AEF_Security_API, defined by 3GPP. The check-authentication endpoint must be requested from Invoker before initiating consumption of exposed API, indicating api_invoker_id. body
- Provider will request security context of api_invoker_id to Provider's CCF, and Provider's CCF will request security context to Invoker's CCF and this security context will be forwarded to Provider, which includes the ca root to decode invoker's certificate and PSK derived by Invoker's CCF.
- Provider will take authenticationInfo, and authorizationInfo present at security_info array inside GET security context response and store them to be used later.
- Invoker reaches exposed API including PSK inside Authorization header.
- Provider validates invoker's PSK towards PSK present on authorizationInfo in security context obtained.

Summary:
In this scenario, Provider must implement AEF_Security_API in order to begin communication by reach check-authentication by Invoker previous start consuming Provider's API.
Provider will request on this initial step the Security Context involved to obtain CA and PSK to be used to validate Invoker's communication.