What is an API?
Tags: testing, beginners, api, webdev
Published: 2023-07-26 05:20:33

If you are new to tech, you might be confused by a term that you’ll see all over the place: API. Let’s take a look at what it means, some examples, and how you can use it.

## Definition

API is the abbreviation for application programming interface. Those words alone probably don't help much, so let’s see what each of them means here.

### Application

Applications are programs that provide some feature(s) to users. They store and retrieve data, perform calculations, etc. Applications give us a reason to use computers at all. The direct usefulness of applications contrasts with programs that we run to access other programs, for example:

* we use the operating system to open applications, and
* we use browsers to access web applications.

### Interface

The interface is an exposed part of an application, prepared to receive input from the outside. As a user, you maybe already be familiar with some types of interfaces:


* graphical user interface (GUI)—the most common interface that we all know from personal computers and mobile devices.
* command line interface (CLI)—where the user types a program name and parameters to run a program.

### Programming

An API is an interface that is meant to be used by other programs. So, instead of exposing buttons or menus, the application provides a way of interacting with it in a machine-friendly way. Nowadays, it is typically understood as a Web API—an online server that exposes different routes and returns data in a format that is both easy to parse for a computer and understandable for humans. 

The name itself doesn’t imply any specific channel of communication—there are other types of APIs as well. On the web platform, we have an ever-growing list of APIs exposed to JavaScript by the browsers. The way of accessing differs, but the method is almost always rather rigid and requires precise interaction with it.

## Intuition

APIs are simply a way for applications to communicate with each other. Good APIs are stable—because a breaking change in one application will require an update in all applications that use it. And good APIs are documented—because otherwise it’s very difficult to write a program that uses them.

## Examples

Let’s take a look at some examples of APIs that you could play around with.

### URL

The URL (uniform resource locator) is a form of an API. As users, we usually use them without thinking much about them. We use a web browser to fetch and display a website from an address that we clicked as a link. With well-designed addresses, we can tweak them and get still get a response from the server:
* when we replace the `Netherlands` part of https://en.wikipedia.org/wiki/Netherlands with `Belgium`, we get a valid URL: https://en.wikipedia.org/wiki/Belgium 
* Some URLs are organized in a nice hierarchy. If we remove parts of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Numbers_and_dates, we go up to:
  * A [list of JavaScript guides](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide),
  * general [JavaScript page](https://developer.mozilla.org/en-US/docs/Web/JavaScript),
  * [Main page](https://developer.mozilla.org/en-US/docs/Web) for web platform documentation.

A well-designed URL system invites us to tweak the address but will not help much if we ask for a page it doesn’t have. For example, when we replace `JavaScript` with `TypeScript`, we get https://developer.mozilla.org/en-US/docs/Web/TypeScript: 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ztuvafyynxvy7u8j10tj.png)

Playing around with URLs can be a simple way of trying out communicating directly with a machine—and getting used to their requirements of providing the parameters in exactly the way they expect.

### Command line programs

Another simple way of starting with APIs are command line programs. Similarly to web APIs, the first step is to read the documentation. Then, make a few trial and error attempts at getting the program to do what you want it to do. In another article, I provide a simple introduction to [CLI programs](https://how-to.dev/the-hitchhikers-guide-to-the-command-line).

### Web API

As a tester or a programmer, you are most likely to use a web API. They are relatively easy to use, but there are some difficulties involved:

* the access can be limited to authorized users—each system will have a different way of authorization and can require creating a user, logging in, providing the session information in cookies or some ID and key pair
* without getting too deep, you can do only GET requests—by pasting the API address into the address bar of your browser. The other types of requests (POST or DELETE) will require either getting some specialized program or writing simple JavaScript in the developer tools of your browser.

Let’s see some examples of APIs that you could experiment with:

* [Open street map](https://wiki.openstreetmap.org/wiki/API_v0.6#URL_+_authentication),
* [Mastodon](https://docs.joinmastodon.org/api/guidelines/),
* [Wikipedia](https://en.wikipedia.org/api/rest_v1/#/).

## What you can do with APIs

The main use of an API is to call other applications from the program you write. You can use them to leverage other systems for any variety of functionalities:

* OAuth for authorization with 3rd-party providers such as Google for Facebook
* getting automated translations from the cloud
* getting geolocation from map systems
* automatically cross-publishing the same content on many social media platforms
* accessing large language models to provide some AI functionality
* and many more

In a way, a lot of modern programming is writing glue code between different APIs.

## How understanding APIs helps you debug

Because so much programming is about calling APIs, there is a lot of troubleshooting that can be done there. Many bugs I ~~created~~ encountered in my frontend programming career were caused by either


* sending an incorrect request to the API, or
* interpreting the response incorrectly.

If the frontend sends a valid request and displays the response as it should, then the bug is probably on the backend. If you can troubleshoot that much as a tester, this can significantly speed up finding and fixing the bug.

## Learn more

If you are interested in learning more about APIs, programming, and testing, [sign up here](https://how-to-dev.ck.page/a5c69742db) for an occasional email from me.