Method and URL
Send GET, POST, PUT, PATCH, or DELETE requests to an API endpoint.
Local API testing
Build a request, inspect the response, and use the optional desktop agent for localhost APIs that browser security rules block.
Enter a URL and click Send to make a request
Browser may block access to cross-origin responses without CORS headers. Run the Desktop Agent to send through your computer.
Use a local HTTP client for localhost or CORS-restricted endpoints. The Agent runs on your computer and sends target requests directly from there, without a JsonifyTools cloud relay.
curl http://127.0.0.1:45456/healthAPI testing guide
An API tester lets you send a request on its own and read the response directly. That gives you a clear place to check the URL, HTTP method, headers, authentication, and JSON body when an integration is not behaving as expected.
Build
Set the endpoint, method, parameters, headers, and body.
Send
Make one request from the browser or local Desktop Agent.
Understand
Use the status, response headers, and body to choose a next step.
The request, in plain terms
A useful API check is a small, repeatable conversation with one endpoint: send the request the service expects, then read its response before changing your application code.
Send GET, POST, PUT, PATCH, or DELETE requests to an API endpoint.
Edit query parameters, custom headers, and JSON or plain-text bodies.
Configure Basic Auth, Bearer tokens, JWTs, or an API key.
Read the HTTP status, response time, size, headers, and formatted body.
| Method | Common purpose | Request body |
|---|---|---|
| GET | Read a resource or list. | Usually no body |
| POST | Submit data or create a resource. | Often has a body |
| PUT | Replace a resource representation. | Usually has a body |
| PATCH | Update selected fields. | Usually has a body |
| DELETE | Ask the server to remove a resource. | Depends on the API |
The API defines the exact behavior for each method. Use its documentation as the contract, especially for PATCH support, required headers, and request-body formats.
Request builder features
Use this online API tester to control the parts of a REST request in one place. Choose an HTTP method and endpoint, then add the query parameters, headers, authentication, and request body required by the API documentation.
Enter an API endpoint and choose GET, POST, PUT, PATCH, or DELETE. This makes it easy to check a read, create, update, or delete route without first writing application code.
Add, edit, or disable key-value parameters such as a search term, page number, or filter. Enabled values are URL-encoded and appended to the endpoint when the request is sent.
Set headers for request formats or API-specific options, including Accept and Content-Type. The tester supplies a JSON or plain-text Content-Type by default when one is not already set.
Write a JSON or text payload for methods that accept a body. The JSON editor can format valid JSON before you send it, helping you inspect nested request data more easily.
Configure Basic Auth, a Bearer token, a JWT, or an API key. Choose whether an API key goes in a header or query parameter, then compare the endpoint response with the credentials it expects.
Keep authentication and custom headers alongside the URL, method, and body for the active request. This gives you a direct way to reproduce the documented API call and inspect what the endpoint returns.
Response and workflow features
After you send a request, use the response details to see how the endpoint behaved. The REST client also includes practical tools for switching between requests and moving a request between the browser interface and a terminal workflow.
Check the HTTP status code and status text, then read the response body for returned JSON, text, or an error message. These details help distinguish a successful response from an authentication, validation, or server error.
Review the response time, body size, and returned headers alongside the status. Use headers to check response content type and other metadata when an endpoint behaves differently than expected.
Keep up to six requests open at once. Each tab retains its own URL, method, parameters, headers, body, authentication, and response, so you can compare endpoints or auth settings without rebuilding each request.
Import a supported cURL command to populate an editable request, or export the active request as a cURL command for terminal testing and sharing. Review commands for credentials before sharing them.
For localhost, Docker, and private-network APIs, the optional Desktop Agent sends the request from your computer. This can help when browser CORS rules prevent the web page from reading a response; the target API's authentication and network rules still apply.
Browser mode sends the HTTP request from your browser to the URL you entered. JsonifyTools does not relay it through a cloud server, so the destination API receives the request and any credentials you configured.
Why test an API on its own?
When a web or mobile app cannot load data, the failure could be in the screen, request construction, authentication, network, or API itself. Sending the same request from an API testing tool removes much of the application around it, so you can inspect the server response directly and decide what to check next.
Recreate the URL, method, headers, and body outside the app. If the request fails here too, you have a smaller surface to investigate.
Compare your request with the endpoint documentation: required fields, accepted content type, query parameters, and expected status.
Send a request with no token and then with the documented auth type. A changed response can help identify an authentication or permission issue.
Import a cURL command from a failed request, inspect its details, then export a focused reproduction for a teammate or terminal.
Where it fits
Use a REST API client while learning an unfamiliar service, implementing an integration, checking a staging endpoint, or investigating a bug report. It is especially useful when you need to see a raw status code or response body that the application normally hides.
A focused REST API client
It keeps a manual API check in one place: build a request, send it, and inspect the real response without first wiring the call into a frontend. Separate tabs keep different endpoints or credentials apart, and cURL import/export helps move between a browser workflow and a terminal reproduction.
For scheduled regression suites, load tests, or tests that must run on every deployment, keep automated checks in your test runner or CI pipeline.
Try a safe public example
JSONPlaceholder provides sample REST endpoints for tutorials and quick experiments. These requests use fake data, so they are useful for learning the request controls without pointing the client at a work or production service.
https://jsonplaceholder.typicode.com/todos/1https://jsonplaceholder.typicode.com/posts
{
"title": "First API check",
"body": "Testing a JSON request",
"userId": 1
}JSONPlaceholder is a fake REST API for testing and prototyping. Its write examples simulate a response; they do not create permanent records. Replace the sample URL and payload with values from your own API documentation when testing your service.
A debugging workflow
Imagine a checkout screen reports only “Could not save order.” Instead of changing frontend code by guesswork, send the same request to the endpoint and inspect the response the server returned.
Before · a vague failure
After · isolate the request
Illustrative workflow · fictional order API
REQUEST SENT
POST /v1/orders
Content-Type: application/json
Authorization: Bearer [test token]
{
"itemId": "sku_demo_42",
"quantity": 1
}The request has a valid route and token, but the order service also expects a shipping address.
RESPONSE INSPECTED
422 Unprocessable Content
Content-Type: application/json
{
"error": "validation_failed",
"fields": {
"shippingAddress.postalCode": "Required"
}
}Now there is a specific next step: compare the missing field with the API documentation and try the request again. This is a fictional response to show how status and body work together.
Confirm a URL responds and see the JSON shape before wiring it into a client.
Compare a request without auth to one with a Basic, Bearer, JWT, or API-key credential.
Try a JSON body and read validation errors without repeating an entire app flow.
Import a supported command, edit its fields, then export a request for terminal use.
Target
Copy the endpoint URL from the API docs.
Method
Choose the method the endpoint expects.
Inputs
Add query parameters, headers, auth, and body.
Send
Run the request and wait for its response.
Inspect
Read status, headers, timing, and body.
Optional local request bridge
Browser CORS is enforced by the browser when page JavaScript calls a different origin. The Desktop Agent changes where the request to your API is made: it receives the request details locally, calls the target API from your computer, then sends the response back to the tester.
Step 1 · Browser
Method, destination URL, headers, authentication, and body are sent to the local agent while it is connected.
Step 2 · Your computer
The local Python service at 127.0.0.1:45456 uses urllib to contact the destination API.
Step 3 · Target API
The service receives the request and returns its actual status, headers, and response body. The Agent passes those details back to the page.
The browser is no longer fetching the API response from the target origin. It talks to the local Agent instead; the Agent makes the outbound request with a native HTTP client, which is not governed by browser CORS. The Agent sends browser-readable CORS headers on its local response. The target API therefore does not need to grant this page CORS access for the Agent to read its reply.
For the browser-to-Agent hop, the local service answers the OPTIONS preflight and returns the CORS and local-network headers the browser expects. A browser may still ask you to allow access to local devices.
It does not add CORS permission to the API or change how your production frontend can call it. The target still checks its route, token, permissions, payload, and network rules. A 401, 403, validation error, or server error still comes back for you to inspect.
Browser mode and local APIs
This online REST client normally sends requests directly from your browser. Browsers enforce the target server’s CORS policy, so a response can be blocked from the page even when the endpoint itself is reachable.
The browser makes the HTTP request. The API must allow this page’s origin when cross-origin response access is required. If you control the API, configure its CORS policy for your development origin and required headers.
For localhost, Docker, or private-network endpoints, run the JsonifyTools Desktop Agent on your computer. It sends the request from the local machine, outside the browser’s CORS enforcement.
Requests go to the API URL you provide; JsonifyTools does not relay them through its cloud. Treat tokens and API keys as secrets, use HTTPS for remote services, and review exported cURL commands before sharing them. The optional local agent prints request URLs and response status in its local console.
A CORS message means the browser did not let this page read the cross-origin response. It does not always mean the API is offline. For a simple request, the server may have replied but omitted the permission header. For a request with JSON content type, Authorization, a custom header, or a method such as PATCH, the browser may send an OPTIONS preflight first; if that check fails, the actual request is not sent.
For the browser rules and response headers in more detail, see MDN’s CORS guide.
If you control the API
Allow the exact origin shown in the browser error, and allow the methods and request headers your client needs. Keep private APIs restricted to trusted origins; a wildcard is intended for public, non-credentialed access.
If the API is not yours
Use the Desktop Agent to inspect the endpoint from your machine, or ask the API owner about supported access. A browser no-cors request is not a useful REST test because the browser hides its response status, headers, and body.
API testing library
Explore practical guides for REST requests, local endpoints, JWT authentication, OAuth access tokens, and safe API security checks. Each guide includes examples and explains where the API Tester fits into the workflow.
Companion developer tools
Use the API Tester to send a request, then open a related tool when you need to inspect JSON, review a JWT’s visible claims, or validate a response shape.
Bring a command into the request editor or turn the active request into a terminal command.
Open up to six tabs to compare endpoints or auth configurations without losing each request’s fields.
Use the status and headers for protocol clues, then inspect the response body for data or validation messages.
Common questions
Answers to common questions about online REST clients, authentication, CORS, and request setup.
An API tester is an HTTP client for building a request and sending it to an API endpoint. Choose a method, enter a URL, add query parameters or headers, configure authentication, and include a JSON or text body when the endpoint expects one. The response view helps you inspect the status, timing, headers, and body.
Start with the endpoint URL and method from the API documentation. Add required query parameters, headers, and authentication, then set a request body for methods such as POST, PUT, or PATCH. Send the request and compare the status code and response body with the endpoint's documented behavior.
In browser mode, the browser applies the target API's Cross-Origin Resource Sharing policy. The API may be running and still block a page from reading its response if it does not allow this site as an origin. Configure CORS on an API you control, or use the optional JsonifyTools Desktop Agent for localhost and other endpoints that need a native request.
Yes. Run the optional JsonifyTools Desktop Agent on your computer and use it to send requests to localhost, Docker, or a private-network endpoint. Without the agent, browser security rules can prevent a web page from reaching local services or reading their responses.
No. It does not edit the target API or its CORS configuration. It sends the request from your computer using a native HTTP client, then returns the response to the API Tester through the local agent connection. Authentication, endpoint rules, and network access still apply.
Use a test credential and a development endpoint when possible. The agent prints request URLs and response status in its local console, so a secret placed in a query string may appear there. The current agent also skips HTTPS certificate verification to support local self-signed certificates, so do not use it to validate a remote server's certificate.
Yes. Open the Auth tab and choose Bearer Token, JWT, Basic Auth, or API Key. An API key can be placed in a header or query parameter. The request sends the configured credential to the endpoint you entered, so use a trusted endpoint and HTTPS for credentials that must remain confidential in transit.
No. Browser mode sends the request from your browser to the endpoint you entered. The optional Desktop Agent runs on your own computer and sends the request from there. The destination API receives the request and any credentials it contains. The local agent also prints request URLs and response status in its local console.
Yes. Use Import cURL to turn a supported cURL command into an editable request, or use Export cURL to create a command from the active request. Review exported commands before sharing them because headers, query strings, or command arguments can contain credentials.
Yes. Open up to six request tabs. Each tab keeps its own URL, method, parameters, headers, body, authentication settings, and response while you switch between them.