The Ten Necessities for Good API Documentation – A Checklist Aside

API documentation is the primary reference for anybody implementing your API, and it will possibly profoundly affect the developer expertise. As a result of it describes what providers an software programming interface gives and the best way to use these providers, your documentation will inevitably create an impression about your product—for higher or for worse.

Article Continues Beneath

On this two-part sequence I share what I’ve realized about API documentation. This half discusses the fundamentals that can assist you create good API docs, whereas partially two, Ten Extras for Nice API Documentation, I’ll present you extra methods to enhance and fine-tune your documentation.

Realizing who you tackle together with your writing and how one can finest assist them will enable you make choices in regards to the design, construction, and language of your docs. You’ll have to know who visits your API documentation and what they wish to use it for.

Your API documentation will in all probability be visited and utilized by the next audiences.


Primarily based on their abilities, expertise, and position in tasks, builders will usually be the most important and most numerous group. They’ll be utilizing your docs in numerous methods.

At Pronovix, we began conducting developer portal workshops with our shoppers to assist them study extra about what builders want and the best way to finest assist their work—and what they’re actually on the lookout for in API documentation. That is additionally supported by stable analysis, such because the findings revealed in Stephanie Steinhardt’s article following a two-year analysis program at Merseburg College of Utilized Sciences.

Newcomers: Builders missing earlier expertise together with your API have a tendency to wish essentially the most assist. They may benefit from quickstart guides that encourage them to start out utilizing your API—clear, concise, step-by-step tutorials for a very powerful matters, and pattern code and examples to assist them perceive the best way to use it in actual tasks. If you can also make onboarding nice for newcomers, they are going to be extra prone to dedicate themselves to studying each nuance of your API.

Exterior builders: Builders already working together with your API will come again repeatedly to your docs and use them as reference materials. They may want fast data on all of the performance your API gives, structured in a straightforward to grasp means to assist them rapidly discover what they want.

Debuggers: Builders utilizing your API will encounter errors every so often and use your documentation to investigate the responses and errors that crop up.

Inside builders: API suppliers are inclined to focus a lot on their exterior viewers that they neglect about their very own builders; inside groups engaged on the API will use the API documentation, as properly.

These are simply the most typical use circumstances.

Determination makers#section4

Determination makers like CTOs and product managers may even take a look at your API documentation and consider your API. They should decide whether or not your API will probably be a superb match for his or her venture or not, so it’s essential to what you are promoting that this group can simply and rapidly discover what they’re on the lookout for.

Different audiences#section5

Though not as widespread, journalists, technical writers, assist employees, developer evangelists, and even your competitors may learn your API documentation.

Keep in mind the aim of documentation#section6

The inspiration of your API documentation is a clear clarification of each name and parameter.

As a naked minimal, you need to describe intimately:

  • what every name in your API does
  • every parameter and all of their potential values, together with their varieties, formatting, guidelines, and whether or not or not they’re required.

Context-based construction#section7

Folks received’t learn your API documentation so as, and you’ll’t predict which half they may land on. This implies, you must present all the knowledge they want in context. So following the most effective practices of topic-based authoring, you need to embody all mandatory and associated data within the clarification of every name.

Context.IO, for instance, did an awesome job documenting every of their API calls individually with detailed data on parameters and their potential values, together with helpful suggestions and hyperlinks to associated matters.

So as to have the ability to implement your API, builders want to grasp it together with the area it refers to (e.g., ecommerce). Actual world examples scale back the time they should get aware of your product, and supply area data on the similar time.

Add the next to the outline of every name:

  • an instance of how the decision is made
  • an evidence of the request
  • pattern responses

Research have proven, that some builders instantly wish to delve into coding, when attending to know a brand new API; they begin working from an instance. Evaluation of eye-tracking information confirmed that visible parts, like instance code, caught the eye of builders who have been scanning the web page, reasonably than studying it line by line. Many checked out code samples earlier than they began studying the descriptions.

Utilizing the precise examples is a surefire strategy to enhancing your API docs. I’ll discover methods to show good API docs into nice ones utilizing examples in my upcoming submit “Ten Extras for Nice API Documentation”.

When one thing goes incorrect throughout growth, fixing the issue with out detailed documentation can change into a irritating and time-consuming course of. To make this course of as clean as potential, error messages ought to assist builders perceive:

  • what the issue is;
  • whether or not the error stems from their code or from the usage of the API;
  • and the best way to repair the issue.

All potential errors—together with edge circumstances—must be documented with error-codes or transient, human-readable data in error messages. Error messages mustn’t solely include data associated to that particular name, but additionally tackle common matters like authentication or HTTP requests and different situations not managed by the API (like request timeout or unknown server error).

This submit from Field discusses finest practices for server-side error dealing with and communication, corresponding to returning an HTTP standing code that intently matches the error situation, human-readable error messages, and machine-readable error codes.

Newcomers beginning to implement your API face many obstacles:

  • They’re initially of a steep studying curve
  • They may not be aware of the construction, area, and concepts behind your API
  • It’s tough for them to determine the place to start out.

When you don’t make the educational course of simpler for them, they will really feel overwhelmed and chorus from delving into your API.

Many builders study finest by doing, so a quickstart information is a good possibility. The information must be brief and easy, geared toward newcomers, and listing the minimal variety of steps required to finish a significant job (e.g., downloading the SDK and saving one object to the platform). Quickstart guides normally have to incorporate details about the area and introduce domain-related expressions and strategies in additional element. It’s most secure to imagine that the developer has by no means earlier than heard of your service.

Stripe’s and Braintree’s quickstart guides are nice examples; each present an summary of the almost certainly duties you’ll wish to carry out with the API, in addition to hyperlink you to the related data. Additionally they include hyperlinks to contact somebody in case you need assistance.

Tutorials are step-by-step walkthroughs protecting particular performance builders can implement together with your API, like SMS notifications, tài khoản verification, and so on.

Tutorials for APIs ought to comply with the most effective practices for writing any type of step-by-step assist. Every step ought to include all the knowledge wanted at that time—and nothing extra. This fashion customers can deal with the duty at hand and received’t be overloaded with data they don’t want.

The outline of steps must be straightforward to comply with and concise. Readability and brevity assist the educational course of, and are a finest observe for every kind of documentation. Keep away from jargon, if potential; customers will probably be studying domain-related language and new expertise, and jargon can instill confusion. Assist them by making all descriptions as straightforward to grasp as potential.

The walkthrough must be the smallest potential chunk that lets the person end a job. If a course of is just too complicated, take into consideration breaking it down into smaller chunks. This makes certain that customers can get the assistance they want with out going by steps they’re not all for.

Screenshot of Twilio's tutorials page
Twilio’s tutorials clarify the most-likely use circumstances with pattern apps in all kinds of programming languages and frameworks.

To implement your API, there are some bigger matters that builders might want to find out about, for instance:

  • Authentication. Dealt with in another way by every kind of API, authentication (e.g., OAuth) is commonly a sophisticated and error-prone course of. Clarify the best way to get credentials, how they’re handed on to the server, and present how API keys work with pattern code.
  • Error dealing with. For now, error dealing with hasn’t been standardized, so you need to assist builders perceive how your API passes again error data, why an error happens, and the best way to repair it.
  • HTTP requests. You could have to doc HTTP-related data as properly, like content material varieties, standing codes, and caching.

Dedicate a separate part to explaining these matters, and hyperlink to this part from every associated API name. This fashion you may guarantee that builders clearly see how your API handles these matters and the way API calls change habits primarily based on them.

Format and navigation#section13

Format and navigation are important to person expertise, and though there isn’t any common answer for all API docs, there are some finest practices that assist customers work together with the fabric.

Dynamic structure#section14

Most good examples of API documentation use a dynamic structure because it makes navigation simpler for customers than static layouts when on the lookout for particular matters in in depth documentation. Beginning with a scalable dynamic structure may even be sure to can simply broaden your docs, as wanted.

Single web page design#section15

In case your API documentation isn’t enormous, go together with a single web page design that lets customers see the general construction at first sight. Introduce the small print from there. Lengthy, single web page docs additionally make it potential for readers to make use of the browser’s search performance.

Screenshot of Stripe's API reference page
Stripe managed to current in depth documentation in a straightforward to navigate single web page.

Persistent navigation#section16

Hold navigation seen always. Customers don’t wish to scroll on the lookout for a navigation bar that disappeared.

Multi-column structure#section17

2- or 3-column layouts have the navigation on the left and data and examples on the precise. They make comprehension simpler by displaying endpoints and examples in context.

Screenshot of Clearbit's API reference page
Clearbit’s three-column structure shows persistent navigation (desk of contents) on the left, references within the center, and code examples on the precise.

Syntax highlighter#section18

Bettering the readability of samples with syntax highlighting makes the code simpler to grasp.

Screenshot of Plaid's API documentation page
The syntax highlighter in motion on Plaid’s API documentation website.

When you’d like to start out experimenting with a structure to your docs, you may wish to take a look at some free and open supply API documentation mills.

To study in regards to the professionals and cons of various approaches to organizing your API docs within the context of developer portals, this is a superb article by Nordic APIs.

All writing that you simply publish ought to undergo an modifying course of. That is widespread sense for articles and different publications, however it’s simply as important for technical documentation.

The writers of your API docs ought to goal for readability and brevity, verify that every one the required data is there, and that the construction is logical and matters aren’t diluted with pointless content material.

Editors ought to proofread your documentation to catch grammar errors, errors, and any components that is likely to be arduous to learn or obscure. They need to additionally verify the docs towards your type information for technical documentation and recommend adjustments, if wanted.

As soon as a piece of documentation is able to be revealed, it’s a good suggestion to point out it to folks in your target market, particularly any builders who haven’t labored on the documentation themselves. They will catch inconsistencies and supply perception into what’s lacking.

Though the modifying course of can really feel like a burden when you must deal with so many different features of your API, a few iterations could make an enormous distinction within the remaining copy and the impression you make.

In case your API documentation is outdated, customers will get annoyed by bumping into options that aren’t there anymore and new ones that lack documentation. This will rapidly diminish the belief you established by placing a lot work into your documentation within the first place.

When sustaining your API docs, you need to control the next features:

  • Deprecated options. Take away documentation for deprecated options and clarify why they have been deprecated.
  • New options. Doc new options earlier than launch, and ensure there’s sufficient time deliberate for the brand new content material to undergo the editorial course of.
  • Suggestions. Helpful suggestions you get from assist, or analytics must be mirrored in your docs. Chances are high you may’t make your docs good on the first attempt, however primarily based on what customers are saying, you may enhance them repeatedly.

For all this to work, you’ll have to construct a workflow for sustaining your documentation. Take into consideration checkpoints and processes for the above talked about features, modifying, and publication. It additionally helps in case you can arrange a routine for reviewing your docs commonly (e.g. quarterly).

Following these finest practices, you may construct a stable basis to your API documentation that may be repeatedly improved upon as you achieve extra perception into how customers work together with them. Keep tuned for half two, the place I provide you with some tips about the best way to flip good API docs into wonderful ones.

Leave a Comment