• Advanced REST client. //install.advancedrestclient.com A better API testing tool! Save your time with the easiest API testing tool out there. On windows it's.
• Top REST API Testing Tools Recap. These are the top API testing tools free I’ve come across, but there are tons of API testing tools popping up everywhere, so I’ll definitely be adding to this list as time goes on. If one of your favorite API test tools is not listed, please let me know and I’ll add it.

• Rest Api Tools For Windows
• Rest Online Tool
• Rest Api Testing Tools

Popular Alternatives to RESTClient for Windows. Explore 24 Windows apps like RESTClient, all suggested and ranked by the AlternativeTo user community. Advanced REST Client (ARC) API testing tool. Which allows web developers to create and test custom HTTP requests. Free Open Source Mac Windows Linux Chrome OS Chrome. Chromium Chrome Web Store. The RESTful Interface tool is a command line interface that allows user to manage Hewlett Packard Enterprise products that take advantage of RESTful APIs. For this release of the tool, user can manage HPE Gen9 servers running iLO 4 2.10 or later through iLO RESTful APIs. User can install the tool on users computer for remote use or user can install the tool locally on a server with a windows OS or Linux OS.

Looking for tools use to test REST API.

So far I'm only aware of SoapUI. I've tried SOAPUI but - at least in a mac - it's terrible.

Wondering what people are using to test their own APIs.

closed as primarily opinion-based by devnull, EdChum, Raul Rene, Pinal, Satish SharmaJul 23 '14 at 8:24

Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise. If this question can be reworded to fit the rules in the help center, please edit the question.

11 Answers

If you're just testing your APIs manually, we've found RestClient 2.3 or the Poster add-on for Firefox to be pretty helpful. Both of these let you build requests that GET, PUT, POST, or DELETE. You can save these requests to rerun later.

For simple automated testing try the Linux (or Cygwin) 'curl' command in a shell script.

From something more industrial strength you can move up to Apache JMeter. JMeter is great for load testing.

31 October 2014: HTTPRequester is now a better choice for Firefox.

July 2015: Postman is a good choice for Chrome

Postman in the chrome store is simple but powerful.

I use http://hurl.it/

Ha. Sorry, I mis-read your post. I've used cucumber to test it before. It worked out nicely.

We are using Groovy to test our RestFUL API, using a series of helper functions to build the xml put/post/gets and then a series of tests on the nodes of the XML to check that the data is manipulated correctly.

We use Poster (for Firefox, Chrome seems to be lacking a similar tool) for hand testing single areas, or simply to poll the API at times when we need to create further tests, or check the status of things.

We're planning to use FitNesse, with the RestFixture. We haven't started writing our tests yet, our newest tester got things up and running last week, however he has used FitNesse for this in his last company, so we know it's a reasonable setup for what we want to do.

More info available here:http://smartrics.blogspot.com/2008/08/get-fitnesse-with-some-rest.html

I am using Fiddler - this is a great tool and allows you to quickly hack on previous http request amending headers / content etc.

Apart from that I am using scipts written in Python (using httplib) , as this is one of the easiest way to create integration test.

I am using DevHttpClient Plugin for chrome, its handy. it does also saves previous actions. clean UI as well

http://www.quadrillian.com/ this enables you to create an entire test suite for your API and run it from your browser and share it with others.

We use Groovy and Spock for writing highly expressive BDD style tests. Unbeatable combo! Jersey Client API or HttpClient is used for handling the HTTP requests.

For manual/acceptance testing we use Curl or Chrome apps as Postman or Dev HTTP Client.

We test our own with our own unit tests and oftentimes a dedicated client app.

There is a free tool from theRightAPI that lets you test any HTTP based API. It also lets you save and share your test scenarios.

Not the answer you're looking for? Browse other questions tagged apirestqafunctional-testingsoapui or ask your own question.

This feature is only supported in the Ultimate edition.

When testing a web service, you can create, edit, and execute HTTP Requests directly in the IntelliJ IDEA code editor.

HTTP Requests are stored in .http and .rest files and are marked with the icon.

Support for HTTP files includes the following features:

• Code completion for method types and header fields

• Inline documentation for request header fields and doc tags

• Viewing a structure of HTTP requests

• Language injections inside the request message body

Before you begin, configure the Proxy settings on the HTTP Proxy page of the Settings/PreferencesCtrl+Alt+S dialog if necessary.

Testing web services is supported via the bundled HTTP Client plugin, which is enabled by default in Settings/Preferences Plugins.

Creating HTTP request files

You can work with HTTP requests either from scratch files or from physical files of the HTTP Request type. Each file can contain multiple requests, and you can create as many files as needed.

Scratch files can be used to test HTTP requests during development. Scratch files are not stored inside a project, so IntelliJ IDEA can modify them and add additional information about the request. When an HTTP request is executed from a scratch file, the link to the response output file is added below the request and at the top of the requests history file.

Create an HTTP request scratch file

Press Ctrl+Shift+Alt+Insert and select HTTP Request.

Physical files can be used for documenting, testing, and validating HTTP requests. Physical files are stored inside your project, and IntelliJ IDEA will not modify them. When an HTTP request is executed from a physical file, this file is not modified. Information about the executed request with the link to the response output file is added to the top of the requests history file.

Create a physical HTTP request file

In the File menu, point to New, and then click HTTP Request.

You can use the Move refactoring F6 to move HTTP requests from scratches to physical files, as well as between physical files.

Move an HTTP request

1. In the editor, position the caret at the request to be moved and do one of the following:

   • From the main menu or the context menu, choose Refactor Move.

   • Press F6.

2. In the dialog that opens, click to select the file or type the full path to the file you want to move the request to. Note that you can specify the name of a non-existing file, in which case a new file with the provided name will be created automatically.

Composing HTTP requests

You can type HTTP requests directly in the created HTTP request files using the following general syntax:

IntelliJ IDEA uses the HTTP request in Editor format, which provides a simple way to create, execute, and store information about HTTP requests. To get an overview of its possibilities, you can explore the HTTP Requests Collection, which is a handful selection of composed requests.

Open a request from the HTTP Requests Collection

1. Click in the top-right corner of the editor or choose Tools HTTP Client Open HTTP Requests Collection in the main menu.

2. From the list, select the HTTP Requests collection you wish to open:

See Exploring the HTTP request in Editor syntax for the syntax and capabilities overview, and HTTP request in Editor specification for the full format description.

To speed up composing HTTP requests, use live templates. For example, gtr expands to a simple GET request; mptr expands to a multipart/form-data POST request.

Converting cURL requests

If you are working with cURL requests, you can convert them into the HTTP request in Editor format.

• Paste the cURL request into an .http file, and it will be converted on the fly.

• Alternatively, select Tools HTTP Client Convert cURL to HTTP Request from the main menu. In the dialog that opens, provide the cURL request.

  When you click Convert, a new scratch file with the converted request will be created and opened in the editor.

Consider the example request:

Upon conversion, this request will look as follows:

The following cURL options are supported:

Using environment variables

When composing an HTTP request, you can parametrize its elements using environment variables. For example, instead of providing the host name in your request explicitly, you can use the {{host}} placeholder. Then you define a set of environment variables in your project holding the desired host definitions. When you execute the request, you choose between defined environments, for example, the host to send the request to:

The selected environment will be used as the default one when Viewing a structure of the request and opening the request in the browser or creating a run/debug configuration for it.

The name of a variable can be arbitrary, but may only contain letters, digits, the underscore symbols _, or the hyphen symbols -. A variable can hold the values for the following request components:

• Request host, port, and path

• Query parameter or value

• Header value

• Arbitrary values provided directly inside the request body or supplied in an external file.

Define environment variables

Environment variables are defined in the environment files.

1. Within a module, create the following files:

   • The rest-client.env.json (or http-client.env.json) is a regular file that contains common variables and is meant to be distributed together with your project.

   • The rest-client.private.env.json (or http-client.private.env.json) is a private file that might include passwords, tokens, certificates, and other sensitive information. This file is added to the list of VCS ignored files by default. The values of variables that are specified in the http-client.private.env.json file override values in the environment file.

2. Populate the created files with the desired variables.

   The following sample http-client.env.json environment file defines two environments: development and production. The additional http-client.private.env.json file holds the sensitive authorization data.

   { 'development': { 'host': 'localhost', 'id-value': 12345, 'username': ', 'password': ', 'my-var': 'my-dev-value' }, 'production': { 'host': 'example.com', 'id-value': 6789, 'username': ', 'password': ', 'my-var': 'my-prod-value' } }

   { 'development': { 'username': 'dev-user', 'password': 'dev-password' }, 'production': { 'username': 'user', 'password': 'password' } }

   The example HTTP request is as follows:

   GET http://{{host}}/api/json/get?id={{id-value}}&key={{unresolved_var}} Authorization: Basic {{username}} {{password}} Content-Type: application/json { 'key': {{my-var}} }

   When you execute the above request, IntelliJ IDEA provides a choice between the defined execution environments:

   Depending on your choice, the resulting request will be one of the following:

   GET http://localhost/api/json/get?id=12345&key={{unresolved_var}} Authorization: Basic dev-user dev-password Content-Type: application/json { 'key': 'my-dev-value' }

   GET http://example.com/api/json/get?id=6789&key={{unresolved_var}} Authorization: Basic user password Content-Type: application/json { 'key': 'my-prod-value' }

   Since the {{unresolved-var}} variable is not defined in the environment file, IntelliJ IDEA will send the {{unresolved-var}} text as part of the request in both cases.

You can manage variables programmatically in your response handler scripts by means of the client.global.get and client.global.set methods.

Using response handler scripts

With response handler scripts, you can programmatically react to a received HTTP response. By using these scripts, you can automatically process the received data as well as validate it against the conditions that you specify. Response handler scripts are provided as a part of the request within the HTTP request file and are executed as soon as a response is received. To view the response handling examples, open the auth-requests or test-responsesrequests collections.

You can insert a response handler script into your request either in-place or by referring to an external file.

Insert the script into the request

• To insert the script in-place, prepend it with > and enclose it in {% %}:

  GET host/api/test > {% // Response Handler Script .. %}

• To insert the script from an external file, prepend it with >:

Response handler scripts are written in JavaScript ECMAScript 5.1, with coding assistance and documentation handled by the bundled HTTP Response Handler library. For in-place scripts, this functionality is enabled automatically. For external scripts, you need to enable it manually.

Enable HTTP Response Handler coding assistance in a JavaScript file

1. Open the script file in the editor.

2. In the context menu, choose Use JavaScript Library HTTP Response Handler.

Refer to Configuring JavaScript Libraries for details.

The HTTP Response Handler library exposes two objects to be used for composing response handler scripts:

• The client object stores the session metadata, which can be modified inside the script. The client state is preserved until you close IntelliJ IDEA. Every variable saved in client.global as variable_name is accessible to subsequent HTTP requests as {{variable_name}}.

• response holds information about the received response: its content type, status, response body, and so on.

To open the HTTP Response Handler library in the editor, position the caret at the library object and press Ctrl+B

Response handler scripts can include tests, which allows you to use the HTTP Client as a testing framework. To create a test, invoke the client.test(testName, function) method. Inside the test, you can assert a condition by invoking the client.assert(condition, message) method, for example:

Executing HTTP requests

1. If you are going to test your own web service, make sure the service is deployed and running.

2. Do any of the following:

   • In the editor, click Run in the gutter next to the request you want to execute. From the list, select Run <request name>.

   • In the editor, select Run <request name> from the request's context menu.

   • Position the caret at the request you want to execute, press Alt+Enter and select the Run <request name> intention action.

   When the request is executed, IntelliJ IDEA automatically creates a dedicated temporary HTTP Request run/debug configuration for it. You can save it as a permanent run/debug configuration if necessary.

Open a request in the browser

You can open an HTTP request in the browser specified on the Web Browsers page of the Settings/Preferences dialog (Ctrl+Alt+S). Select your system default browser or the one of your choice.

Do any of the following:

• Position the caret at the request first line and choose View Jump to Source from the main menu, or press Ctrl+B or F4.

• Ctrl+Click the request line:

Working with HTTP Request Run/Debug Configurations

You can execute HTTP requests by using run configurations of the HTTP Request type. With the run configuration, you can execute a request at any point, add it to the Services tool window, or a compound configuration.

Refer to Working with Run/Debug Configurations for details.

Create an HTTP Request run/debug configuration

1. Do any of the following:

   • In the editor, select Create <configuration name> from the context menu of the request you want to create a run/debug configuration for.

   • Alternatively, choose Run Edit Configurations from the main menu, then click and choose HTTP Request from the list.

2. Free print shop. Provide the run/debug configuration parameters:

   • In the Environment list, select an environment that will define the set of environment variables used in the request.

   • In the File field, provide the path to the HTTP request file. You can type the path manually and use path completion Ctrl+Space as you type, or click and select the required folder in the dialog that opens.

   • If your request file contains multiple requests, in the Request list choose the index of the request to execute.

When you execute an HTTP request from the editor, IntelliJ IDEA automatically creates a temporary run/debug configuration with the request parameters. A temporary run/debug configuration works the same way as a permanent run/debug configuration. You can change its settings using the Run/Debug Configuration dialog and optionally save it as permanent.

Save a temporary HTTP Request run/debug configuration

Do any of the following:

• In the Run/Debug Configuration selector, choose Save <configuration name>.

• In the Run/Debug Configuration dialog, select the configuration and click the Save icon ().

• In the editor, select Save <configuration name> from the context menu of the executed request.

Execute a request using a run/debug configuration

Do any of the following:

• In the Run/Debug Configuration selector, select the desired run configuration. Then click the Run icon () on the main toolbar or press Shift+F10.

• Press Shift+Alt+F10, select the desired run configuration from the list, and press Enter.

Viewing responses from web services

When you execute an HTTP request, IntelliJ IDEA automatically saves the response into a separate file under the .idea/httpRequests/ directory. You can view the 50 most recently stored responses and navigate to the corresponding files using the requests history. If the request was executed from a scratch file, the link to its response output is also added below the original request:

The cookies received through a response are automatically saved into the dedicated http-client.cookies file under the .idea/httpRequests/ directory. The number of cookies that can be saved is limited to 300. The name and value of a cookie are automatically included in each subsequent request to the URL that matches the domain and path specified for the cookie, provided that the expiry date has not been reached.

If necessary, you can prevent saving the received cookie to the cookies jar by adding a comment line with the @no-cookie-jar tag before the request.

View a received response

1. Switch to the Run tool window, which opens automatically as soon as a response is received.

2. By default, the server response is shown in the format specified in the request header via the content-type field. To have the response converted into another format, click View as HTML , View as XML , or View as JSON .

3. The results of the tests executed as part of a response handler script, if any, are displayed on the Tests tab of the Run tool window.

Open a response file in the editor

• Position the caret at the link to the response you want to open, and choose View Jump to Source from the main menu, or press Ctrl+B or F4.

• Ctrl+Click the response line:

Compare responses in a scratch file

When a request is executed from a scratch file, the link to the response output file is added below the original request.

Do any of the following:

• Position the caret at the link to the response file. Press Alt+Enter and select the Compare with <response name> intention action.

• Click the icon in the left gutter and select Compare with <response name> from the list:

Compare responses in the requests history

When a request is executed from a physical file, the link to the response output is added to the requests history.

1. Position the caret at the link to the response file. Choose View Jump to Source from the main menu, or press Ctrl+B or F4 to open this file in a new editor tab.

2. Choose View Compare with.. from the main menu, or press Ctrl+D. IntelliJ IDEA will prompt you to open a response file from the httpRequests folder.

3. Select the response file you would like to compare the current file with and click Open.

The two response files will be opened in the Differences viewer allowing you to compare their contents:

Viewing requests history

IntelliJ IDEA automatically saves the 50 recently executed requests into the http-requests-log.http file, which is stored on the project level under the .idea/httpRequests/ directory. Using the requests history, you can quickly navigate to a particular response as well as issue any request again. If a request is issued again from the requests history, its execution information and the link to the response output are added to the top of the requests history file.

Open requests history

Rest Api Tools For Windows

Click in the top-right corner of the editor or choose Tools HTTP Client Show HTTP Requests History from the main menu.

If necessary, you can prevent saving a request to the requests history by adding a comment line with the @no-log tag before the request. This can be helpful in case a request contains some sensitive data, and you don't want to log it.

Rest Online Tool

Configuring proxy settings

Rest Api Testing Tools

1. In the Settings/Preferences dialog Ctrl+Alt+S, choose System Settings under Appearance & Behavior, then choose HTTP Proxy.

2. In the Proxy dialog that opens, select Manual proxy configuration and specify the following:

   • Enter the proxy host name and port number in the Host name and Port number fields.

   • To enable authorization, select the Proxy authentication checkbox and type the username and password in the corresponding fields.