ReqRes Getting Started: Mock API for Development & Testing (2026)

Getting started overview

ReqRes is a free, hosted mock API service designed to facilitate frontend development, testing, and prototyping by providing a simulated backend for common RESTful operations. This guide outlines the process of initiating interaction with the ReqRes API, from understanding its operational model to executing your first API call. The service does not require an account or API keys, streamlining the setup process for immediate use.

The primary benefit of ReqRes is its simplicity and instant availability. Developers can send standard HTTP requests (GET, POST, PUT, DELETE) to predefined endpoints and receive predictable JSON responses. This functionality supports testing UI components, demonstrating API integrations, or learning API interaction without the overhead of setting up and maintaining a dedicated backend server.

Key features include:

• Predefined Endpoints: Access to common resources like /users, /register, and /login.
• CRUD Operations: Support for creating, reading, updating, and deleting data.
• Pagination: Built-in support for paginated responses on list endpoints.
• No Authentication: Simplifies initial setup and testing by removing the need for API keys or tokens.

Before proceeding, ensure you have a tool capable of making HTTP requests. Command-line tools like cURL or graphical clients like Postman or Insomnia are commonly used for this purpose.

Quick start reference

The following table provides a high-level overview of the steps to get started with ReqRes:

Create an account and get keys

ReqRes differentiates itself by not requiring users to create an account or obtain API keys for access. The entire service is designed for immediate, unauthenticated use, making it accessible for quick testing and prototyping scenarios. This approach eliminates typical setup hurdles associated with API integration, such as registration forms, email verification, or key generation processes.

To begin using ReqRes, you simply direct your HTTP client to the base URL https://reqres.in/api/ and append the desired endpoint path. Because there are no accounts or keys, there is no dashboard or portal to manage credentials.

API access without credentials

The absence of authentication mechanisms means:

• No Signup: You do not need to register on the ReqRes website.
• No API Keys: No API keys, tokens, or OAuth credentials are required in your request headers or parameters.
• Public Data: All data accessed or modified through ReqRes is publicly visible and not specific to any user session. This makes it unsuitable for sensitive data or production applications requiring secure user data.

This design choice supports its primary use case as a mock API for development and learning, where the focus is on simulating API interactions rather than securing real-world data. For applications requiring robust authentication, developers typically implement standards like OAuth 2.0 for secure authorization or API key management systems, which are not part of the ReqRes service model.

Your first request

To make your first request to ReqRes, you will target an endpoint that returns a list of users. This is typically a GET request to the /users endpoint. We will demonstrate this using cURL, a common command-line tool for making HTTP requests, and then describe how to achieve the same with a graphical client like Postman, which is detailed in Postman's documentation.

Using cURL

Open your terminal or command prompt and execute the following cURL command:

curl -X GET https://reqres.in/api/users?page=2

This command performs the following actions:

• curl: Invokes the cURL utility.
• -X GET: Specifies the HTTP method as GET. This is often optional for GET requests as it's the default, but explicitly stating it can improve clarity.
• https://reqres.in/api/users?page=2: The target URL.
• https://reqres.in/api/ is the base URL for the ReqRes API.
• users is the endpoint for retrieving user data.
• ?page=2 is a query parameter requesting the second page of user data.

Upon successful execution, the terminal will display a JSON response similar to this:

{
    "page": 2,
    "per_page": 6,
    "total": 12,
    "total_pages": 2,
    "data": [
        {
            "id": 7,
            "email": "[email protected]",
            "first_name": "Michael",
            "last_name": "Lawson",
            "avatar": "https://reqres.in/img/faces/7-image.jpg"
        },
        {
            "id": 8,
            "email": "[email protected]",
            "first_name": "Lindsay",
            "last_name": "Ferguson",
            "avatar": "https://reqres.in/img/faces/8-image.jpg"
        },
        {
            "id": 9,
            "email": "[email protected]",
            "first_name": "Tobias",
            "last_name": "Funke",
            "avatar": "https://reqres.in/img/faces/9-image.jpg"
        },
        {
            "id": 10,
            "email": "[email protected]",
            "first_name": "Byron",
            "last_name": "Fields",
            "avatar": "https://reqres.in/img/faces/10-image.jpg"
        },
        {
            "id": 11,
            "email": "[email protected]",
            "first_name": "George",
            "last_name": "Edwards",
            "avatar": "https://reqres.in/img/faces/11-image.jpg"
        },
        {
            "id": 12,
            "email": "[email protected]",
            "first_name": "Rachel",
            "last_name": "Howell",
            "avatar": "https://reqres.in/img/faces/12-image.jpg"
        }
    ],
    "support": {
        "url": "https://reqres.in/#support-heading",
        "text": "To keep ReqRes free, contributions towards server costs are appreciated!"
    }
}

This response indicates that your request was successful (HTTP status code 200 OK, though cURL doesn't show it by default) and returned the expected paginated list of user objects.

Using Postman

For a graphical interface, you can use Postman:

1. Open Postman and create a new request.
2. Set the HTTP method to GET.
3. Enter the request URL: https://reqres.in/api/users?page=2.
4. Click the "Send" button.

Postman will display the JSON response in a formatted panel, making it easier to inspect the data. You can find detailed instructions on sending basic requests in Postman's learning center.

Common next steps

After successfully making your first GET request, you can explore other HTTP methods and endpoints provided by ReqRes to simulate more complex API interactions. These steps will help you further test your frontend or learn about RESTful API design.

Experiment with other HTTP methods

ReqRes supports the full range of standard HTTP methods, allowing you to simulate creating, updating, and deleting resources:

• POST Request (Create User): To create a new user, send a POST request to /api/users with a JSON body containing the new user's details. For example:

  curl -X POST -H "Content-Type: application/json" -d '{"name": "morpheus", "job": "leader"}' https://reqres.in/api/users

  The response will include the id and createdAt timestamp for the newly created user.

• PUT Request (Update User): To update an existing user, send a PUT request to /api/users/{id} with a JSON body containing the updated details. For example, to update user with ID 2:

  curl -X PUT -H "Content-Type: application/json" -d '{"name": "morpheus", "job": "zion resident"}' https://reqres.in/api/users/2

  The response will reflect the updated fields and an updatedAt timestamp.

• DELETE Request (Delete User): To delete a user, send a DELETE request to /api/users/{id}. For example, to delete user with ID 2:

  curl -X DELETE https://reqres.in/api/users/2

  A successful delete typically returns an empty response with a 204 No Content status code, indicating the resource was successfully removed.

Explore additional endpoints

Beyond user management, ReqRes offers other simulated endpoints for authentication-related actions:

• Register Successful: Send a POST request to /api/register with valid email and password fields:

  curl -X POST -H "Content-Type: application/json" -d '{"email": "[email protected]", "password": "pistol"}' https://reqres.in/api/register

  This will return a token if successful.

• Login Successful: Similar to registration, a POST request to /api/login with valid credentials:

  curl -X POST -H "Content-Type: application/json" -d '{"email": "[email protected]", "password": "pistol"}' https://reqres.in/api/login

  Returns a token upon successful login. For more details, consult the ReqRes API documentation.

Integrate with a frontend framework

ReqRes is particularly useful for frontend developers. You can integrate ReqRes API calls into your JavaScript applications (e.g., React, Vue, Angular) using the fetch API or libraries like Axios. This allows you to build and test your UI components that rely on API data without needing a functional backend. For example, you might use fetch to populate a user list on a webpage by calling https://reqres.in/api/users.

Troubleshooting the first call

When making your first API call to ReqRes, you might encounter common issues. Here are some troubleshooting tips to help resolve them:

1. Network connectivity issues

• Check your internet connection: Ensure your device has an active internet connection.
• Verify URL accessibility: Try opening https://reqres.in/api/users directly in a web browser. If you can see a JSON response, the server is accessible.
• Firewall/Proxy: If you are in a corporate network, a firewall or proxy might be blocking outbound HTTP requests. Consult your network administrator or try from a different network.

2. Incorrect URL or endpoint

• Typos: Double-check the URL for any typos. Ensure it is exactly https://reqres.in/api/users?page=2.
• HTTP vs. HTTPS: Always use https:// for secure communication.
• Endpoint existence: Refer to the ReqRes API documentation to confirm the correct endpoint paths.

3. HTTP method errors

• Wrong method: Ensure you are using the correct HTTP method for the operation. For retrieving data, it should generally be GET. For creating, POST; for updating, PUT; for deleting, DELETE.
• cURL -X flag: If using cURL, explicitly set the method using -X GET, -X POST, etc.

4. JSON body formatting (for POST/PUT requests)

• Syntax errors: If sending a JSON body with POST or PUT requests, ensure the JSON is valid. Tools like JSONLint can validate your JSON syntax.
• Content-Type header: Always include the -H "Content-Type: application/json" header when sending JSON data in the request body.
• Quoting issues: In cURL, ensure your JSON body is correctly quoted, especially when using single quotes for the entire JSON string.

5. Understanding response codes

Familiarize yourself with common HTTP status codes:

• 200 OK: Successful GET, PUT, POST.
• 201 Created: Successful POST (resource created).
• 204 No Content: Successful DELETE (no content to return).
• 400 Bad Request: The server cannot process the request due to client error (e.g., malformed JSON, missing required fields).
• 404 Not Found: The requested resource does not exist. Check your URL and endpoint.
• 500 Internal Server Error: A generic error indicating a problem on the server side. While rare with ReqRes, it can occur.

By systematically checking these points, you can often quickly identify and resolve issues preventing your first successful interaction with the ReqRes API.