Standardization is a fact of business. Every industry or sector, across every activity from software development, food preparation, or recruitment, is affected by a standard that influences how ‘something’ is done. The API economy is no exception to the effect of standards.

API standards are often considered both an enabler and an inhibitor of growth and competition, with some arguing against standardization in favor of market forces. Nevertheless, several industries are required to publish APIs built to a pre-defined specification. Open banking is the obvious example, where banks must deliver APIs to the market to increase competition and allow other service providers to meet customer needs.

Other sectors, from healthcare to telecommunications, have endeavored to create standards around common API-related functions. In this post, we consider the efforts of the CAMARA Project, an API standards body for telcos that has recently become a Linux Foundation project, and the effect standardized APIs might have on the telco industry.

API Standards for Telcos

Having consistent standards has been a must for telcos since the days of yore and the birth of the industry. Mobile network operators must be interoperable, work at a massive scale, and process hundreds of billions of calls and call records. Having standards that facilitate this scale is natural to the telco industry. For example, Transferred Account Procedures, or TAP for short, was invented in 1991 and has allowed cell phone networks to exchange roaming billing records for decades. Most GSMA standards and technologies have a similar legacy to TAP.

However, standardized network APIs elude the telco industry. Standardized network APIs allow common functions of operator networks, such as making a call, to be invoked consistently across any network, reducing integration time and increasing efficiency for API consumers. McKinsey cites standardized network APIs as being worth between $100 billion and $300 billion, so there is certainly a compelling case for implementing them.

However, many non-operators still have to deal directly with standards like TAP or integrate with different APIs across different networks. Implementing network APIs has had limited success for many reasons, from the network operators’ fears of changing market dynamics and disruption to continued rapid product development as networks move to 5G. CAMARA is, therefore, looking to address the standardization aspect through common APIs.

What Is the Goal of CAMARA?

CAMARA aims to move telco networks away from point-to-point integrations and ad-hoc APIs on specific technology stacks to generic, abstracted, and common APIs that can unlock network value. According to the CAMARA website, this approach is necessary as it will “pave the way for transforming operator networks into service enablement platforms, facilitating the application-to-network integration, which will be key to deliver enhanced and service tailored customer experience in the 5G era.”

The transformation from a network to a platform and the focus on custom experience mirrors a general trend throughout the API economy. API providers deliver their products and services through a means that is based on their platform being a black box, meaning customers only need to understand the APIs and not the inner workings, promoting scale and efficiency. Doing the same thing at the telco network level, allowing developers to ignore the guts of the underlying network operator, will achieve the same efficiencies and help accelerate innovation as network integration becomes a commodity.

Take the example of initiating a mobile call from a web page or application, where the browser or app hands off to a provider to make the call. The provider could be the operating system of a mobile phone or an application that provides calling capabilities. There is a huge number of ways to do this, with different capabilities based on the providers’ implementation, varying through mobile operating systems, providers like Twilio, and network operators. CAMARA, therefore, provides the ClickToDial API, with a sub-project on GitHub and a standardized design for implementing an API. The means to initiate dialing a number becomes a simple API, described in OpenAPI:

paths:
  /clicktodialbegin:
    post:
      summary: The app calls this API to establish a call between caller and callee.
      operationId: ClickToDialBegin
      tags:
        - Click To Dial Begin
      requestBody:
        description: Contains the information for the creation the resource.
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ClickToDialBeginRequest'
      responses:
        '200':
          description:  The result of Click to Dial Begin 
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ClickToDialBeginResponse"
        '400':
          $ref: '#/components/responses/Generic400'
        '403':
          $ref: '#/components/responses/Generic403'
        '500':
          $ref: '#/components/responses/Generic500'          
        '504':
          $ref: '#/components/responses/Generic504'

The CAMARA API standards replicate this simplicity for approximately 30 common operations. Here are a few other examples:

• Device location, which is important for geolocation and geofencing capabilities and could be consistently supplied by a network operator.
• SIM swaps, which allows a customer’s phone to be accurately paired with their current device, supporting capability mapping more accurately for service provision.
• Number verification, which provides assurance and security for phone users in verifying the number received is made from the phone paired with the SIM.

These examples extend to any similar function or operation that an application developer needs to cater to when interacting with a telco network. CAMARA could, therefore, unlock significant value for network operators and API consumers in the telco industry. Network APIs have been an acknowledged goal in the industry for many years and have enormous value. As such, simplifying network integration through API standardization is an important goal.

The Challenges of Increasing API Standardization

Before embracing API standards, however, the telco industry should reflect on the lessons learned in existing open API ecosystems like open banking and open finance. Alongside API standards, an ecosystem needs rules of engagement, an operating model, a trust framework, and an established and easily-used security model. Some of these features are absent in open banking markets, which has inhibited trust and adoption, as an open API ecosystem must provide a network experience. A network experience cannot be achieved solely by implementing standardized APIs.

There are also other kids on the block in telco API standards. For example, TM Forum has launched an open API program to promote standardization across the telecoms industry. While TM Forum professes to work with CAMARA on standards, open banking shows us how ineffective collaboration across standards bodies can be, with a multitude of standards for account data sharing and payment initiation across the world. One of the key recommendations for PSD3 in the EU is a common, universal API standard for banking APIs, so recent history already shows how important a joined-up approach is.

Creating API standards is great for interoperability and unlocking closed platforms but does not necessarily deliver a money-printing machine. APIs need a commercial imperative to be successful and, in the case of open API ecosystems, a universal operating model for API providers and API consumers. API standards only grease the wheels of commerce. It takes delivering something people want through the products and services built on top of them to unlock the real value.