When everything is working as it should, it's easy not to think about the APIs you use in everyday work. If something were to break down though, you'll need to be able to access API documentation so you can start putting it right. That's why you need to be able to write good, clear API documentation that can be used across your company.
Here's everything you need to know about API documentation, including what it is, who writes it, and how it should work.
What is an API?
Firstly, you're going to need to know what an API is, and what it does. API stands for Application Programming Interface. It's what allows two applications to communicate with each other and share data. This is used over all kinds of programs, and as such allows them to offer the functions you need.
On a very basic level, an API allows you to check the weather on your phone. When you click the icon for the weather app on your phone, an API is accessed. The request is sent to the API, and it goes to a back-end server to get the information for you. The API then brings that info back to you, so you can see what the weather is like today.
As you can see, the API is built on the idea of requests and responses. If you make a request on an API, you'll want to get the correct response back. These are built into the computing system in the modern age, and we use them for so many different applications.
What is API documentation?
Now you understand APIs, you need to understand the need for documentation. At a basic level, the documentation for any API should contain information about how the API works, parameters, endpoints, requests, and responses.
The information contained in the document should be explicit, so it's easy for anyone reading to understand how the API works and implement them.
As a business, you'll want to have documentation in place for all your APIs. When you have it ready, you're prepared in case you should ever need it. The documentation should show the ideal working structure of an API, so if something were to go wrong it can be fixed easily.
What does API documentation look like? The document itself can vary, depending on the writer, but it will need to contain some key essentials:
- Resource description
- Resource URL
- Endpoints and methods
- Request examples
- Code examples
- Response example
- Status and error codes
Depending on the API you're creating documentation for, it could be laid out like so:
|Descriptions of fields in response body||Code examples|
This is only one example though, and you can lay yours out in a way that suits you and your API. Typically though, as you'll need to include similar information you can always create templates for your API documentation. This allows you to create them quickly and easily, every time.
Who can write API documentation?
Who in your business should be handling API writing? You'll be surprised to learn that you don't actually have to be a programmer in order to handle it. As long as you understand how APIs work, then you can start putting the documentation together.
However, writers do need to have some technical knowledge in order to write the best documentation. If you have good tech knowledge, you can do everything from writing to publishing and editing. For those that are more tech weak, they may need to stick to just publishing.
Who writes the documents will depend on your organisation, and who's available to do so. If you have the developers on site as part of your staff, then they are the best choice. They're going to know the code inside and out, and so will be able to create the best documentation for you. However, some feel that coders aren't the best technical writers, and their priority is not going to be writing when they're on the clock. However, with their knowledge, they may be the best choice for you.
You can also call on technical API writers to handle creating the documentation for you. Typically they won't have programming knowledge, but they will work closely with the developers. They will learn about the API as they write about it, and they will have a knowledge of the concepts behind the coding.
Types of API documentation
What you need to know is there are actually several different types of API documentation that you can create. You'll need to pick the type that works best for you and your needs. These include:
Reference:This is the core document about any API. It needs to cover all the information, in detail. That includes the structure, parameters, return values, and more. When writing a reference document, it's essential that everything is described. For example, every single endpoint and asset needs to be covered. These are the documents that developers use most, so they need to have everything available to them in it.
Conceptual:This document isn't designed to show the ins and outs of an API, as a reference document would. Instead, it's there to show the reader what the API can and cannot do. These are written to show what the API can be used for, and what can be built with it.
When creating a conceptual document, you'll want to give examples of how you can integrate it with other APIs to create other programs, as well as tutorials about the API keys needed to authorize requests.
Tutorials: The final API documentation type is a step by step guide to implementing the API in question. They typically focus on the specific functions, so they act as a guide to getting a certain result from the program.
This is what you'll put together when you're looking to help users get a certain result from the API. They should be able to use the documentation to get the exact data they're looking for.
What to include in API documentation
Now you should nearly be ready to start writing your API documentation. Every document will be slightly different, so you'll want to keep this in mind when you're looking to get started. What will you need to include?
The best way to answer this question is to understand who you're writing for. The audience will change what you include. Normally, you'll either be writing for developers or technical marketers, and each audience will require different things from you.
If you know who your audience is too, you'll be able to consider what coding language to use in the document. Knowing the audience means knowing what kind of coding languages are popular with them. When you come to include coding examples, you can use those languages to make things easier.
One of the most important things to remember is that API documentation will differ a lot from company to company. Don't worry too much if yours doesn't turn out looking like others you've seen online. As long as you're including the right information, your documentation should work.
There are four questions you should ask yourself when writing, to ensure you're including what's needed:
- What does a user need to get to the endpoint or perform the required action?
- What are the authentication requirements for accessing data?
- What info gets returned, and how should it be interpreted?
- How can the user try these functions out?
How to create an API document
How are you going to start writing your API document? As mentioned earlier, typically you'll be able to use a template which takes a lot of work off your hands right away. As such, it's a good idea to find a program that helps with this.
For example, 82% of companies tend to use OpenAPI Specification(formerly known as Swagger), so that's something that you'll want to consider. When you add the UI block to your editor, it will give you a template that you can start using. It will be filled with dummy data for a pet store, which you can easily edit out and replace with your own data. It's helpful, especially for those who've never written documentation before, as they'll be able to see where everything should go.
This isn't the only tool you can use to create the document, though. There are lots others out there, from open source to paid for, that you can use. You can try using a few of them to see which ones suit you and your needs best. For example, you can try Archbee, Redox, Github pages,, and more.
If you're not using a UI to create your documents, you'll need to put the structure together yourself. As such, you'll need to work your way through the URL, parameters, request structure, and response structure. You should be able to get the details from the development team, and they'll help you get all the details down.
Tips for creating the best document
There's no one single way to create a good, easy to use API document. Every business will have different needs, so you'll need to keep these in mind as you write. However, it does help to keep the following tips in mind.
Avoid jargon:This is one of the most important things you should do. Again, you need to think of the audience for what you're writing. It's easy to start putting in terms that make sense to you and your department. However, you'll need to take a step back and think if your audience will understand it too. If they won't, then scrap the jargon and use another more universally understood term.
Remember that when the documentation is being used, you will probably not be there to explain it or walk the user through it. It needs to be as clear as can be, so avoid using jargon as much as you can.
Avoid auto generated documents:You'll see that there are auto generating tools out there that can create a document with the API you have already. It's tempting to use these, as you'll think they'll save you time. The fact is, though, they aren't as useful as they seem.
As they're auto generated, they won't be written in a way that's easily understood. That's going to make them frustrating to use , and you'll have more work ahead of you in cleaning them up and getting them to a usable state.
Describe, describe, describe:For every step in the document, you'll need to describe what is happening. Describe the resources, the parameters, the end point, the request and response bodies, and more. You need to have all the detail there, so the reader knows what they should expect the API to do.
You'll want to include this detail as the document should cover everything that the reader needs to know. If you can do this, then they can use it and get the results that they're looking for.
Create a good introduction:An introduction should give the reader a starting point when they're looking at using the document. In the intro, you can include what the API is and what it should do on a basic level. When the reader has this context, they can then understand the rest of the document.
Some writers will decide the intro isn't important and cut it, but make sure that you don't make that mistake. It only needs to be a line or two, and that should be enough to get the reader started.
Create interactive examples:When someone is reading your documentation, not only will they want to see how it can be used, they'll want to see it in action too. As such, you want to ensure you're adding interactive examples to the text.
Many API UIs will actually let you create examples that readers can test in real time. For example, the Deezer API lets you test the endpoints at the click of a button, so the reader can get the responses and see how it works. Try this for yourself in your writing.
Keep the documents maintained: Your work isn't done once you've written the API documentation. Once it's done and ready to use, you'll need to keep revisiting it. There may be changes to the API itself, and that's going to change how you use the documentation.
Keep on top of any changes made, and ensure that you make edits to the documentation when that happens. If you do that, you'll ensure that it's always up to date.
Keep it to one page: If possible, it's usually best to keep your document to one page or less. It's a balancing act, as you're looking to include as much detail as you can without overloading the reader.
To do this, it's a good idea to try the templates that are out there online. They'll help you keep everything to a minimum, and make the page easy to read. When you keep it to one page, there isn't going to be piles of info that a reader will need to wade through.
Reviewing API documentation
Once the document is written, you'll need to sit and read it through, to ensure that everything has been implemented correctly. This step is vital, no matter how much you're in a hurry to get it done.
If there are any mistakes in the text, they can have a huge effect on the usability of it. That's especially true in the code snippets that you've included as examples. If a reader tries to implement it in the same way and there's an error, they aren't going to get the result that they want.
As such, take the time to do a few passes. You'll want to go through once looking for any spelling or grammatical errors, another for factual errors, another for issues with code, and so on. If you're using interactive examples, test them to make sure they work too.
It's often helpful to have someone else take a look at the document too. They may be able to spot issues with the text that you missed.
Once the documentation has been thoroughly proofread and edited, it's ready to be used.
Now you know the basics of creating good API documentation. When written correctly, they'll show the entire process of the API, and how it can be used. Ensure you know who you're writing for, include all the details they need to know, and keep the language simple and to the point.
Sara Sparrow is a technical writer and project coordinator, working with OX Essays writing service.