Groove with the Funky API Versioning Boogie
Tags: api, softwareengineering, programming, webdev
Published: 2023-08-31 14:37:06


![vector](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/usq7czrp163de4d3tcet.jpeg)

I love playing [vector](https://nekki.com/vector/) because it features a free runner who is not held by the system who runs, jumps and climbs to avoid capture by the protectors of the system. The rush, the breaking off from a system has a thrill that takes you from reality a bit. I got excited when they introduced a new version in June `v2.0.0` which means we had a bump in terms of introduction of new features like Hard mode, level of the day, updated interface, graphics and sounds improvements as well as new gadgets. There have been patches made till `v2.0.4` which was released on August. The Patch contained optimizations for levels 1-2 and bug fixes to ensure that we all have a good time playing. 

[APIs](https://dev.to/veldakiara/the-nitty-gritty-of-api-methods-2m4h) change due to the constant evolution of software and user requirements. The strategy to manage the changes and updates is known as API versioning. 

## Factors To Consider During Versioning

a. **Semantic Versioning**: communicates the meaning of version numbers in the software in use by consumers through MAJOR.MINOR.PATCH. Vector uses semantic versioning, as demonstrated by their recent upgrade to `v2.0.4`.

The first number (`2`) indicates the major version changes, which indicate that the software has undergone a significant change through either a new feature introduction or breaking changes.

The second number (`0`) indicates minor version changes that are backward compatible, like new features or bug fixes.

The third number (`4`) indicates patch version changes, which are bug fixes that are backward compatible.

**Rules for Semantic Versioning**
Major version number changes only if there are vital changes that break compatibility with previous versions.

Minor version numbers are incremented only if there are slight changes to the software that are backward-compatible.

The patch version number is incremented only if there are bug fixes that are backward compatible.

**Benefits of Semantic Versioning**

- Makes it easier to track changes being made.
- Helps in communicating the meaning of version numbers to clients.
- Makes it easier for consumers to choose the right version of software for their needs.
- Reduces compatibility challenges between different versions of software

b. **Backward Compatibility**: making sure that existing clients can still communicate with the new version of the API, especially after major version updates. Existing clients should continue to use the API without any disruption when changes are made to it.

c. **Forward compatibility**: new clients that adapt the API after version updates should be able to interact with it seamlessly without any issues.

d. **Depreciation Period**: This is what I like to refer to as the notice period, for example, if you are leaving a job or a rental. This is applied to versioning too, where the maintainers and owners of the API inform users that a version of the API is about to be deprecated and how long they have to update their code to avoid issues with requests. This can be done through documentation or response headers.

e. **Documentation**: This is the first point of contact for the user. Clearly document the changes made in each version and provide migration guides to help developers transition to newer versions. Keep the documentation updated at all times.

f. **API Stability**: API endpoints and field names should remain constant or stable within a version. Avoid making frequent changes.

g. **Error Handling**: Handle versioning-related errors by providing informative error responses to clients, indicating that they are using an unsupported or deprecated version.

h. **Communication with Clients**: Clients of the API need to be informed about changes, updates, and deprecated features so they can adapt their code accordingly. This can be done through sending emails, newsletters, blog posts, and release notes.


## API Versioning Methods

There are different ways to choose from on how to implement versioning.  

[URL path versioning ](https://usecsv.com/community/api-versioning#:~:text=Versioning%20through%20URL%20Path&text=For%20example%2C%20you%20can%20include,to%20only%20use%20the%20major)is where the version number is included in the URL path.

Example: [Twitter API](https://developer.twitter.com/en/docs/platform-overview)

`Original Endpoint: https://api.twitter.com/1.1/statuses/user_timeline.json`

`New Version Endpoint: https://api.twitter.com/2/statuses/user_timeline.json`

[Query parameter versioning](https://blog.hubspot.com/website/api-versioning#:~:text=Query%20Parameters,instead%20of%20in%20the%20path) is a method of versioning REST APIs where the version number is included as a query parameter in the URL. 

Example: [GitHub API](https://docs.github.com/en/rest/quickstart?apiVersion=2022-11-28)

`Original Endpoint: https://api.github.com/repos/octocat/Hello-World/issues`

`New Version Endpoint: https://api.github.com/repos/octocat/Hello-World/issues?version=2`

[Header versioning](https://restfulapi.net/versioning/) is a method of versioning REST APIs where the version number is included as a custom header in the HTTP request. 

Example: [Stripe API](https://stripe.com/docs/api)

`Original Endpoint: https://api.stripe.com/v1/charges`

`New Version Endpoint: https://api.stripe.com/v1/charges?Stripe-Version=2019-12-03`

`Header: Stripe-Version: 2019-12-03`

[Media Type Versioning](https://apigility.org/documentation/api-primer/versioning.html): The version number is specified within the media type (MIME type) of the request or response.

Example: [Microsoft Graph API](https://learn.microsoft.com/en-us/graph/use-the-api)

`Original Content Type: application/json`

`New Version Content-Type: application/vnd.microsoft.graph.v2+json`

[Namespace Versioning](https://docs.oracle.com/middleware/11119/fp/concepts/chapter07.htm): Versioning is incorporated into the namespace of the API's codebase or endpoint structure.

Example: [Amazon S3 API](https://docs.aws.amazon.com/AmazonS3/latest/API/Welcome.html)

`Original Endpoint: https://s3.amazonaws.com/v1/bucket/object
`

`New Version Endpoint: https://s3.amazonaws.com/v2/bucket/object`

[No Versioning (Depreciated and Sunset Strategy)](https://nordicapis.com/how-to-smartly-sunset-and-deprecate-apis/): API providers choose not to version their APIs but rather maintain a deprecated phase for old features while introducing new ones. This approach requires clear communication with clients about the deprecation timeline.

Example: [Facebook Graph API](https://developers.facebook.com/docs/graph-api/overview/)


## Best Practices For API Versioning

a. **Start with v1**: Begin your API versioning with v1.0.0. It's easier to manage and plan for future versions once you start with v1.

b. **Maintain Only a Few Active Versions**: Supporting too many versions can become cumbersome for the team. Aim to maintain only a few active versions and periodically depreciate and sunset older versions.

c. **API Documentation**: Keep your API documentation up-to-date and clear. State the versioning strategy being used and the changes between versions.

d. **Testing and Monitoring**: Thoroughly test each version of the API and actively monitor API usage to identify potential issues and vulnerabilities.

e. **Error Reporting**: Implement proper error reporting and logging to track version-specific issues.

f. **Communication**: Communicate version updates and deprecations to your API users through release notes, blog posts, or email newsletters.

g. **Granularity**: Consider the granularity of versioning. For minor changes, endpoint-level versioning might be enough, while major changes may require a full version update.


This article has gone through an overview of API versioning, from its fundamental concepts to consider to the best practices for its implementation. By understanding the principles of API versioning, developers and stakeholders can ensure that their APIs are versioned in a way that is easy to understand, use and that minimizes the impact of changes to the API on their users. This will help to ensure the longevity, compatibility, and seamless evolution of APIs, fostering robust and adaptable systems for the future.