Top API Testing Tools for 2023

List of the best API testing tools free and open source for 2023.

Application Programming Interface (API) testing is more important now than ever. That why I create this list of the top free API Testing Tools you should know.

As we move towards more Agile shift-left software development processes like continuous integration and delivery, the need to quickly give test feedback to our developers is increasing.

One downfall to UI tests is that they are slow, making them a poor choice for letting developers know quickly if their code has broken the latest build.

On the other hand, API tests tend to be faster and run more reliably than GUI tests.

Below is a quick API testing tools comparison of open-source options.

Before we take a closer look at the API testing tools, let’s ensure we’re all on the same page with what an API actually is.

What is an API?

An API is a specification that acts as an interface for software components.

While most functional testing involves testing a user interface like a web page or a dot net form, API testing bypasses a user interface and communicates directly with an application by making calls to its APIs.

API testing allows you to test headless technologies like JMS HTTP, databases, and Web services.

API testing is sometimes called “headless” testing. Most headless testing consists of bypassing the UI and sending a request directly to an application's backend or service and receiving a response while validating the response to ensure things are working as we expect them to.

This simple example is often referred to as a client/server relationship. A client makes a request by asking for a resource; the request then goes out and finds a server that can fill that request. The server locates the desired resource and sends a response back to the client.

What API Testing Tools Can I Use to Automate API Testing?

Since Selenium is just for browser-based testing, you may wonder which tool to use for Rest and Soap web service-based testing.

Here are some of the top API testing tools that can be used for Rest and Soap Web Service Testing. API tools are great because, many times, you can leverage one test script to help with API load/stress performance testing, security testing, and penetration testing.

So let's get to it.

Although there are many great paid options, here are the top free API testing tools you should check out.

Postman 

Postman is a rest client that started off as a Chrome browser plugin but recently came out with native versions for both Mac and Windows.

At a high level, you can use it to send a post request to your web server, and it gives you a response back. It allows you to set up all the headers and cookies your API expects, then check the response when it returns.

• Can be used for both automated and exploratory testing
• Can be run on Mac, Windows, Linux &Chrome Apps
• Has a bunch of integrations like support for Swagger & RAML formats
• Has Run, Test, Document and Monitoring Features
• Doesn’t require learning a new language

To hear how Postman is used in the real world for testing video games, check out Amber Race's TestTalks episode on Testing Video Games Using API Automation.

CON: Lately, Postman's features have become paid options, although they still have a free plan. Thats why more testers are migrating to tools like Karate.

Karate DSL 

Karate allows you to create a test to sequence calls to any web service (SOPA or REST) and assert that the responses are as expected. If you're a tester, this is a very tester-focused tool that doesn't require you need to know how to code.

Karate is known for being easy to read and, thus, very maintainable. This is an often overlooked aspect of choosing a test framework because test suites are used for continuous integration as long as the API is live in production.

• It has an easy-to-use human-like syntax
• Can run a test and generate reports like any standard Java project
• A test can be written without any Java knowledge required
• Tests are easy to write, even for non-programmers

Here is an example Karate script:

Feature: TestGuild search

  Scenario: Search for a keyword on testguild.com
    Given url 'https://www.testguild.com/'
    And driver
    When driver.get
    Then driver.findElementByCss('#s').input('automation')
    And driver.findElementByCss('.search-submit').click()
    And driver.waitForUrl('/?s=automation')
    Then driver.titleContains('automation')

Feature: TestGuild search Scenario: Search for a keyword on testguild.com

SoapUI 

SoapUI is a headless functional testing tool from SmartBear software. It comes in two flavors: A free open-source version and Pro Version. Since the free version is open-source, you can actually gain access to the full source code and modify it as needed.

The SoapUI Pro version is user-friendlier and has additional functionality, including a form editor, an assertion wizard for XPath, and a SQL query builder.  The free version lets you:

• Can easily create custom code using Groovy
• Drag and Drop Test Creating
• Can create complex scenarios
• Asynchronous Testing
• SoapUI’s Mock Service lets you mimic web services before they are implemented.

Listen to Mike Giller of Smartbear talk more about SoapUI and API Testing.

HttpMaster Express 

HttpMaster describes itself as a web development and test tool to automate the testing of websites and services. It can be used to test RESTful web services and API applications. HttpMaster also allows you to and monitor API responses.

• HttpsMaster project offers global options to customize your API request
• Parameter capabilities enable you to include dynamic data with your request
• You can use request chaining to leverage request items to include some data from the previous request with the next request

Rest- Assured 

Rest-Assured is an open-source Java Domain-specific language (DSL) that simplifies testing REST service. It simplifies things by eliminating the need to use boiler-plate code to test and validate complex responses. It also supports XML and JSON Requests/Responses. This is probably the best-known tool to test rest API.

• Removes need to create boilerplate code required to interact with a rest service
• Support BDD Given/When/Then syntax
• Integrated seamlessly with Java projects
• Probably the standard for programmatically creating a rest API testing tool script

If you use Java and want a REST API web services library you can use in your framework, Rest-Assured is a good choice. Bas Dijkstra recently also created a C# version.

Johan Haleby, creator of Rest-Assured, shares tips and tricks for getting started with REST testing with Rest-Assured.

RoboHydra Server 

Looking for API integration testing tools?

RoboHydra is a testing tool for HTTP-based clients (i.e., software that makes HTTP requests). The idea is, instead of connecting your clients-under-test to the real server, you connect them to RoboHydra and make RoboHydra respond with whatever you need for each request.

To use RoboHydra for an API test that goes to say testguild.com and searches for “API automation testing,” you'll need to create a simple proxy server with RoboHydra and then write a test script to perform the search.

• You can test many different kinds of clients
• Written in Javascript, runs under Node 

Hippie-Swagger 

hippie-swagger is a tool for testing RESTful APIs. It’s also an API testing tool with automatic swagger assertions. In addition to validating API behavior, it will fail tests when swagger documentation is missing or inaccurate.

• Can validate All aspects of a swagger file validated; parameters, request/response body, paths, etc.
• Accurate, human-readable assertion messages

Pyresttest 

PyRestTest is a python-based REST testing and API micro-benchmarking API testing tool.

• You can write your tests in basic YAML or JSON config files; no code is needed
• Returns exit codes on failure
• It only works on Mac and Linux

it's easy to get started all you need to do is install pip install pyresttest

Then Create a YAML test file that for example, test will check if the GitHub API returns a 200 status code when requesting public repositories.

---
- config:
    name: "GitHub API Test"
    timeout: 5
    headers: {'User-Agent': 'PyRestTest'}

- test:
    name: "Get public repositories"
    url: "https://api.github.com/repositories"
    method: "GET"
    expected_status: [200]

And run the test:

resttest.py https://api.github.com github_api_test.yaml

Airborne 

Airborne is an open-source Ruby-based API testing framework built on top of RSpec. RSpec is a popular behavior-driven development (BDD) testing framework in the Ruby ecosystem. Airborne simplifies testing RESTful APIs by providing a set of convenient methods and matchers for making HTTP requests and validating responses.

Key features of Airborne:

• Works with Rack applications like Sinatra and Grape
• Works with APIs written in Rails
• Easy-to-use: Airborne provides a simple and readable DSL (Domain-Specific Language) that makes it easy for developers and testers to write API tests.
• JSON support: Airborne is designed with JSON in mind, making it easy to parse, validate, and manipulate JSON response bodies in your API tests.
• Built on RSpec: As Airborne is built on top of RSpec, you can leverage the full power of RSpec matchers and its BDD-style syntax.
• Custom matchers: Airborne includes a set of custom matchers to validate API responses, such as checking the presence of specific keys or validating the types of values in JSON objects.
• Extensible: You can easily extend Airborne by adding custom matchers or using existing RSpec plugins to enhance your API testing experience

To use, all you need to do is use the following gem files

gem install airborne
gem install rspec

Then create a test file github_api_spec.rb:

require 'airborne'

describe 'GitHub API' do
  it 'retrieves public repositories' do
    get 'https://api.github.com/repositories'
    expect_status(200)
    expect_json_types('*', id: :integer, name: :string, full_name: :string)
  end
end

And then run the test: rspec github_api_spec.rb

Mockbin 

Mockbin is an open-source tool that allows you to create, deploy, and manage mock APIs. It can be useful for API testing, especially when you need to simulate API responses or test against specific scenarios without actually hitting the real API endpoints.

• Mock Custom Endpoints
• Create Custom HTTP Methods
• Log and inspect incoming calls to your custom endpoints

Citrus Framework 

Not sure why more folks aren't aware of the Citrus Framework. Citrus is an open-source framework that can help you automate integration tests for virtually any messaging protocol or data format. It has nice test results reports as well.

• Works with REST, SOAP, HTTP, JMS, TCP/IP and more
• Create tests using Java or XML
• Mature – has been around awhile

For more info on Citrus, Integration testing, check out API Integration Automation Testing With Citrus Framework.

ZeroCode

ZeroCode describes itself on GitHub as a community-developed, free, open source, microservices API automation and load testing framework built using JUnit core runners for HTTP REST, SOAP, Security, Database, Kafka, and much more. Zerocode Open Source enables you to create, change, orchestrate, and maintain your automated test cases declaratively easily.

Here are some benefits of using ZeroCode:

• ZeroCode is built on JUnit core runners (no plugins needed)
• Just your IDE or any JSON editor is enough to drive the tests
• Very easy to write tests – as simple as Postman REST-Client
• You can still do BDD, but without syntax overhead
• Performance testing – Load/Stress generation is quite easy and existing tests can be reused
• Efficient Reports – You can do a fuzzy search as well as filter by any text, and track by author

Katalon Studio

Katalon Studio is an all-in-one test automation solution that supports web, mobile, and API testing. It offers a comprehensive set of features and a user-friendly interface, making it suitable for both beginners and experienced testers. Katalon Studio can be used for API testing to ensure the functionality, reliability, performance, and security of your RESTful and SOAP web services.

Some benefits of Katalon Studio are:

• It's not open-sourced but it is free
• It’s a complete package and framework. So it is easy to install and get working
• Small learning curve
• It has functionality that allows you to test web services and REST APIs

Listen to my interview with Raghav Pal to discover more about Katalon studio.

JMeter

As you might already know, JMeter was developed for load testing, but many testers also use it for  API testing and as an API load testing tool as well.

Some benefits of JMeter are:

• Can leverage one API test script for both API and as an API Performance testing
• JMeter has been around awhile so it's time-tested
• Easily integrated into CI/CD environments

Tavern

Tavern is a pytest plugin, command-line tool and API testing tools Python library for automated testing of APIs. It's designed for testing RESTful APIs. It uses the powerful pytest testing framework to create a simple, concise, and flexible way to write API tests. Tavern allows you to write API tests in YAML format, making them easy to read and maintain. Additionally, since Tavern is built on top of pytest, you can leverage pytest's advanced features and plugins to enhance your API testing experience.

• • Simple, concise and flexible YAML-based syntax.

• • It’s very simple to get started,

• • highly customizable for complex tests.

• Supports testing RESTful APIs as well as MQTT based APIs.

Chakram

Chakram is a REST Javascript API testing tools framework that also has a BDD testing style and fully exploiting promises. So you can use it for

• HTTP Assertions
• Chakram fully exploits javascript promises
• BDD formatting and hooks
• Very extensible

RestBird

RestBird is a collection of Rest API Tools like autotest, mock server and record, and playback functionality. I just learned about it from a comment someone left for this post. It looks promising. Some benefits of RestBird are:

• Easy to use and Debug
• Fully restAPIi support to be integrated with JIRA, Jenkins, Team City, Bugzilla, Slack
• programmable response validation through Python/Golang scripts

If you read this fear, you might be asking yourself, “Can't you also use some of the more popular browser automation testing tools for API testing?” The answer is YES for instance.

Playwright for API testing

You can do API testing using Playwright, although Playwright is primarily designed for end-to-end testing of web applications. Playwright is a Node.js library that automates browser actions, making it perfect for testing web applications in multiple browsers, including Chromium, Firefox, and WebKit. However, you can also use it with other libraries to perform API testing.

For example, use the “axios” Promise-based HTTP client for the browser and node.js to request an API from a Playwright script.

Yes, you can do API testing using Playwright, although Playwright is primarily designed for end-to-end testing of web applications. Playwright is a Node.js library that automates browser actions, making it perfect for testing web applications in multiple browsers, including Chromium, Firefox, and WebKit. However, you can use it in combination with other libraries to perform API testing as well.

Here's an example of how you can perform API testing using Playwright, along with the “axios” library to make API requests:

First, install the required libraries:

npm init -y
npm install playwright axios

Create a test file, e.g., api_test.js, and import the required libraries:

const { chromium } = require('playwright');
const axios = require('axios');

Define an async function to perform the API testing:

async function testAPI() {
  // Launch a browser instance using Playwright
  const browser = await chromium.launch();
  const context = await browser.newContext();
  const page = await context.newPage();

  // Navigate to the target API URL (replace with your API URL)
  const apiUrl = 'https://api.example.com/data';

  // Use axios to make an API request
  const response = await axios.get(apiUrl);

  // Check the response status and data
  if (response.status === 200 && response.data) {
    console.log('API Test Passed:', response.data);
  } else {
    console.error('API Test Failed:', response.status, response.statusText);
  }

  // Close the browser instance
  await browser.close();
}

testAPI();

Remember that this is just one way to perform API testing using Playwright. Playwright is a versatile library that can be combined with many other libraries and frameworks to perform more complex API testing.

What about API testing using Cypress — sure!

Cypress for API Testing

Just like Playwright, Cypres is a popular end-to-end testing framework for web applications. Although Cypress is mainly designed for browser automation and testing web applications, it also provides functionality for testing APIs using the cy.request function.

Here is an example of how that would look

describe('API Test', () => {
  it('GET request', () => {
    // Replace with your API URL
    const apiUrl = 'https://api.example.com/data';

    // Make a GET request using Cypress
    cy.request(apiUrl).then((response) => {
      // Check the response status and data
      expect(response.status).to.equal(200);
      expect(response.body).to.have.property('data');
    });
  });
});

Top API Testing Tools Recap

These are the top API testing tools free I’ve come across, but tons of API testing tools are popping up everywhere, so I’ll definitely be adding to this list as time passes.

If one of your favorite API test tools is not listed, please let me know, and I’ll add it.