A REST API is an API that follows the design principles of the REST (or REpresentational State Transfer) architecture. In this guide, you will learn about what REST APIs are.

Learn REST APIs

<Callout>

This guide is only meant for beginners. If you already know what REST APIs are, you can check out the [REST API guide for experts](https://rapidapi.com/learn/rest-apis/rest-api-for-experts).

</Callout>

At the end of this guide, you will know the following:

-   What is an API?
-   What is HTTP?
-   What are REST APIs?

Learn REST APIs for Beginners

To understand REST APIs, you need to understand what an API (or Application Programming Interface) is and how they work.

## What is an API?

An API or Application Programming Interface is a set of guidelines or rules that state how applications interact. An API lets one application request data from another system.

<WhatIsAPI />

## Why are APIs important?

An API lets one application use the capabilities of another system. This means that if you want to build an e-commerce application, you can concentrate on building only your product. You can use the API of different applications for payments, billings, authentication, etc.

## Example of an API

Imagine that you are building a trading platform. You will need to support various features like exchange of currency, fluctuation of market rates, authentication, payment processing, and much more. Building and maintaining such functionalities is difficult. To resolve these issues, you can use integrations with various other software via APIs.

## Request, Response, and Resource

The three main components of an API are Request, Response, and Resource. You would make a **request** to a server. The server will return a **response** that will contain data regarding a **resource**.

For example, if you want to place a new order for a shirt in an e-commerce store, you would click on the "place order" button. When you click on that button, your browser sends a **request** to the e-commerce server. The e-commerce server will send a **response** to your browser after creating a new order, which is the **resource** in this case.

## Anatomy of an API request

| Name     | Description                                                    |
| -------- | -------------------------------------------------------------- |
| Endpoint | The **URL** that you request for                               |
| Method   | The **type** of your request                                   |
| Headers  | **Additional information** for either the client or the server |
| Body     | **Information** sent to the server                             |

<AnatomyOfAPIRequest />

## Anatomy of an API response

| Name    | Description                                                    |
| ------- | -------------------------------------------------------------- |
| Headers | **Additional information** for either the client or the server |
| Body    | Data related to the **resource** requested from the server     |

<AnatomyOfAPIResponse />

An API or Application Programming Interface is a set of guidelines or rules that state how applications interact. An API lets one application request data from another system.

What is an API?

## What is HTTP?

**HTTP** (or Hypertext Transfer Protocol) is a protocol generally used by web services for serving HTML documents. A client requests to a server for a resource, and the server sends a response.

## What are the different methods of HTTP?

HTTP has a fixed number of methods that the client can use to indicate what type of operation it wants to perform via the request. These request methods are also known as HTTP verbs.

There are 9 HTTP methods:

1. GET
2. POST
3. DELETE
4. PATCH
5. PUT
6. HEAD
7. TRACE
8. CONNECT
9. OPTIONS

GET, POST, PATCH, PUT and DELETE are the most popular.

### GET

The **GET** request is used to request data from a server.

For example, when you visit an e-commerce website, the browser will make a **GET** request to fetch all the details. Once the server responds to the **GET** request, the browser will show a list of items.

Click on the **Submit** button below to make a **GET** request.

<HTTPClient method="GET" isRequestMethodChangeDisabled showSimplifiedResponse />

### POST

The **POST** request is used to send some data to the server.

For example, when you want to place an order on an e-commerce website, the browser will make a **POST** request to save that information on the server.

Click on the **Submit** button below to make a **POST** request.

<HTTPClient
	method="POST"
	isRequestMethodChangeDisabled
	showSimplifiedResponse
/>

### PATCH and PUT

The **PATCH** AND **PUT** requests are used most often to update on the server.

The main difference between **PATCH** and **PUT** is that **PATCH** is used to partially modify a resource, whereas **PUT** is used to update the entire resource on the server.

Click on the **Submit** button below to make a **PATCH** request.

<HTTPClient
	method="PATCH"
	isRequestMethodChangeDisabled
	showSimplifiedResponse
/>

### DELETE

The **DELETE** request is used to delete the specified resource.

Click on the **Submit** button below to make a **DELETE** request.

<HTTPClient
	method="DELETE"
	isRequestMethodChangeDisabled
	showSimplifiedResponse
/>

## What are status codes?

When the server returns a response, a three-digit number is also sent as a part of the response. This three-digit number is also known as the "status code". Status codes help in identifying the type of the response:

| Name          | Range of status codes |
| ------------- | --------------------- |
| Informational | 100-199               |
| Successful    | 200-299               |
| Redirection   | 300-399               |
| Client error  | 400-499               |
| Server error  | 500-599               |

For example, a successful **GET** request will return a **200** status code.

Click on the **Request data** button in the component below to send requests to the **News application** server. The News application server will return some random status code.

<StatusCode />

HTTP (or Hypertext Transfer Protocol) is a protocol generally used by web services for serving HTML documents. A client requests a server for a resource, and the server sends a response.

What is HTTP?

## What is a REST API?

A REST API is an API that follows the design principles of the REST (or REpresentational State Transfer) architecture.

REST APIs communicate via HTTP requests to perform CRUD (or Create, Read, Update, and Delete) operations.

| Name   | HTTP method |
| ------ | ----------- |
| Create | POST        |
| Read   | GET         |
| Update | PUT, PATCH  |
| Delete | DELETE      |

Click on the **Create new user** button in the component below to understand how to create, update, read and delete a resource via a REST API.

<RESTAPI />

A REST API is an API that follows the design principles of the REST (or REpresentational State Transfer) architecture. REST APIs communicate via HTTP requests to perform CRUD (or Create, Read, Update, and Delete) operations.

What is a REST API?

## About this course

This interactive course will guide you through understanding what a REST API is and how it works.

Use the interactive component below to understand the response from a `GET` request. Click on the **Submit** button to request a response from the server:

<HTTPClient method="GET" isRequestMethodChangeDisabled showSimplifiedResponse />

Use the interactive component below to understand the response from a `POST` request. Click on the **Submit** button to request a response from the server:

<HTTPClient
	method="POST"
	isRequestMethodChangeDisabled
	showSimplifiedResponse
/>

Learn REST APIs for Experts

When a client requests to the server, the client can pass additional information as a part of the request via HTTP headers. As mentioned earlier, headers are case insensitive.

Headers can contain information about the type of data that the client is sending to the server. It can also contain information about authenticating a user agent with the server.

Headers can be grouped into four types based on their contexts:

## Request headers

In an HTTP request, [the Request headers](https://developer.mozilla.org/en-US/docs/Glossary/Request_header) pass information about the request. It contains information about the requested resource and the client making the request.

A request header can contain information about the type of the request, the URL to which the request is being made, authentication details, cache policy as well as the user agent.

Some of the popular request headers are:

### Accept

The [Accept](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept) HTTP header informs the server about the type of data that the client can understand.

```json
Accept: text/html
Accept: application/xhtml+xml
Accept: image/png
```

### Accept-Encoding

The [Accept-Encoding](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding) HTTP header informs the server about the type of encoding the client is able to understand.

```json
Accept-Encoding: gzip
Accept-Encoding: gzip, compress
```

### Authorization

The [Authorization](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization) HTTP header is used to pass credentials which lets the server authenticate a client and provide access to protected resources.

```json
Authorization: Basic YWxhZGRpbjpvcGVuc2VzYW1l
Authorization: Bearer eyYWxhZGRpbjpvcGVuc2VzYW1l
```

## Accept-Language

The [Accept-Language](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language) HTTP header lets the server know which local is preferred and understood by the client.

```json
Accept-Language: fr-CH
Accept-Language: en-US
```

### Cache-Control

The [Cache-Control](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control) HTTP header holds caching instructions for the client and the server.

```json
Cache-Control: stale-while-revalidate=60
Cache-Control: no-cache
```

Use the interactive component below to understand the `Cache-Control` HTTP header from a `GET` request. Click on the **Submit** button to request a response from the server:

<HTTPClient
	method="GET"
	isRequestMethodChangeDisabled
	isResponseBodyVisible={false}
	isResponseHeadersVisible
/>

## Response headers

Like the request headers contain information about the client, [the response headers](https://developer.mozilla.org/en-US/docs/Glossary/Response_header) contain information about the server from which the resource is requested. All headers in a response message can be called response headers.

Some response headers like [Age](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Age), [Location](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location), or [Server](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Server) can give a more detailed response context.

## Representation headers

[The Representation headers](https://developer.mozilla.org/en-US/docs/Glossary/Representation_header) contain information about the resource body, which is sent in a response.

Representation headers include the following:

### Content-Type

The [Content-Type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Type) HTTP header indicates the media type of the resource before any form of content-encoding.

```json
Content-Type: text/html; charset=UTF-8
```

Use the interactive component below to understand the `Content-Type` HTTP header from a `GET` request. Click on the **Submit** button to request a response from the server:

<HTTPClient
	method="GET"
	isRequestMethodChangeDisabled
	isResponseBodyVisible={false}
	isResponseHeadersVisible
/>

### Content-Encoding

The [Content-Encoding](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding) HTTP header is used to decode the message payload to obtain the original format of the payload. It is used primarily to do lossless compression of the payload.

```json
Content-Encoding: compress
Content-Encoding: gzip
```

### Content-Language

The [Content-Language](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Language) HTTP header indicates the language intended for a particular type of audience. If no `Content-Language` is specified, the content is intended for all language audiences.

```json
Content-Language: en-US
Content-Language: en-CA
```

### Content-Location

The [Content-Location](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Location) HTTP header indicates an alternate location for the response. Based on the `Accept` request header, the server can respond with different response headers.

```json
Content-Location: /documents/bar.json
Content-Location: /documents/bar.php
```

## Payload headers

[The Payload headers](https://developer.mozilla.org/en-US/docs/Glossary/Payload_header) contain information about the payload like the length of the message, range of the resource carried in the payload, encoding, etc. These headers can be present in both the request and response messages.

Payload headers include the following:

### Content-Length

The [Content-Length](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length) HTTP header indicates the size of the message body in bytes.

```json
 Content-Length: 3495
```

### Content-Range

The [Content-Range](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Range) HTTP header indicates the position of a partial message in a full body message.

```json
Content-Range: bytes 500-1000/*
```

When a client requests to the server, the client can pass additional information as a part of the request via HTTP headers. As mentioned earlier, headers are case insensitive. Headers can contain information about the type of data that the client is sending to the server. It can also contain information about authenticating a user agent with the server.

Different types of HTTP headers

HTTP has a fixed number of methods that the client can use to indicate what type of operation it wants to perform via the request. These request methods are also known as HTTP verbs. A request method can be safe, idempotent, or cacheable.

If an HTTP method doesn’t alter the server's state apart from logging, it is called a [safe method](https://developer.mozilla.org/en-US/docs/Glossary/Safe/HTTP). `GET`, `HEAD`, or `OPTIONS` methods are safe methods. It is important to note that all the safe HTTP methods are also idempotent, but not all idempotent HTTP methods are safe.

When multiple calls of an HTTP method yield the same result and leave the server in the same state, then the HTTP method is called [idempotent](https://developer.mozilla.org/en-US/docs/Glossary/Idempotent). When implemented correctly, the `GET`, `HEAD`, `PUT`, and `DELETE` methods are all idempotent, but not the `POST` method.

If the response of an HTTP method can be cached and used later, then the method is called cacheable. `GET`, and `HEAD` methods are [cacheable](https://developer.mozilla.org/en-US/docs/Glossary/cacheable). `POST` and `PATCH` methods are also cacheable if [the Content-Location header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Location) is set. The 200, 203, 204, 206, 300, 301, 404, 405, 410, 414, and 501 status codes are cacheable.

The details about [GET](https://rapidapi.com/learn/rest-apis/introduction/what-is-http#get), [POST](https://rapidapi.com/learn/rest-apis/introduction/what-is-http#post), [PATCH, PUT](https://rapidapi.com/learn/rest-apis/introduction/what-is-http#patch-and-put) and [DELETE](https://rapidapi.com/learn/rest-apis/introduction/what-is-http#delete) HTTP request methods have already been discussed.

Let's discuss the remaining methods.

## HEAD

[The HEAD request](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD) method is used to get the data about the resource’s header without a body. This method is similar to the `GET` request but with the body of the response. The `HEAD` request shouldn’t contain a body.

## CONNECT

[The CONNECT request](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/CONNECT) method is used to open a tunnel that can be used to access websites using [SSL](https://developer.mozilla.org/en-US/docs/Glossary/SSL). When a client sends a `CONNECT` request to a Proxy server, the server tries to establish an HTTP tunnel between the client and the server. Once the connection is established, the proxy server can forward the request to the requested endpoint.

## OPTIONS

[The OPTIONS request](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/OPTIONS) method is used to obtain information about the communication options that are available between the requested URL and the server. The response to an `OPTIONS` request isn’t cacheable.

The response to an `OPTIONS` request can be the following:

```bash
Allow: OPTIONS, GET, HEAD, POST
```

If [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) is enabled on the server, [a preflight request](https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request) is sent with the OPTIONS method so that the server can respond if it can accept requests from the requested URL.

## TRACE

[The TRACE request](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/TRACE) method is used to perform a remote, application-layer loop-back of the request message. The final recipient can be the origin server, the first proxy, or the gateway, which should indicate if the message was received from the client by responding with a status code of 200.

HTTP has a fixed number of methods that the client can use to indicate what type of operation it wants to perform via the request. These request methods are also known as HTTP verbs. A request method can be safe, idempotent, or cacheable.

Different types of HTTP methods

Roy Fielding created REST in 2000. REST (Representational State Transfer) APIs are those APIs that follow the guidelines of REST architecture. They are also known as RESTful APIs.

REST APIs follow six design principles which are as follows:

1. **Client-server Separation:** The application which is requesting the resource is called the client, and the application which has the resource is called the server. When the client requests a request to the server, the server sends a response to the client. The server can’t initiate a request to the client. In a RESTful API, the client and server are always kept independent of each other. This ensures that both the client and the server can be scaled independently.

2. **Stateless:** In a RESTful API, each request needs to contain the data that is necessary to process it. Servers aren’t allowed to store any data related to the client. No session or authentication state is stored on the server. If the client requires authentication, then the client needs to authenticate itself before sending a request to the server.

3. **Cacheable:** In REST APIs, the resources should be able to cache themselves either on the client or on the server. When a client requests a resource from the server, the response from the server will contain the information on whether the resource can be cached or not and for how long. The main idea of caching is to improve the performance of the client by reducing the bandwidth required to load the resource.

4. **Layered System:** In REST APIs, there can be multiple intermediaries between the client and the server. It isn’t always necessarily true that the client connects directly to the server and requests a resource. There can be multiple systems in between them that are responsible for handling security, traffic, balancing the load, redirection, etc. The client or the server doesn’t have any information about how many systems are in between them.

5. **Uniform Interface:** All requests and responses in a REST API should follow a common protocol. This allows the applications to evolve independently. The client and server can interact with each other in a single language irrespective of the architecture that they are based upon.

6. **Code on Demand (optional):** When a client requests a resource, the server can return executables as a part of the response. This is an optional constraint. In certain cases, this might help reduce the amount of code that has to be written on the client.

Roy Fielding created REST in 2000. REST (Representational State Transfer) APIs are those APIs that follow the guidelines of REST architecture. They are also known as RESTful APIs. Learn about the six design principles of REST APIs.

Principles of REST API

## CSP

[CSP](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) is a protocol that can be used to provide an additional level of security over various issues like [XSS](https://developer.mozilla.org/en-US/docs/Glossary/Cross-site_scripting), data injection, etc. CSP can be enabled on a server by passing [the Content-Security-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy) HTTP response header. It is a security measure that prevents attacks from running malicious content on a web application.

Using CSP, it is possible to limit the amount of data sources that a web application can load. This is done by properly configuring the CSP headers.

The syntax looks like this:

```bash
Content-Security-Policy: <policy-directive>; <policy-directive>
```

An example of a CSP header can be the following:

```bash
Content-Security-Policy: default-src https://website.com; img-src *; child-src 'none';
```

You can enforce HTTPS for all the resources that your application use by using the following CSP policy:

```bash
Content-Security-Policy: default-src https:; script-src https: 'unsafe-inline'; style-src https: 'unsafe-inline'
```

CSP can prevent errors that occurs due to unsigned inline JavaScript and CSS style tags as well as JavaScript code using `eval()`.

CSP should be used for any application containing user interactions via forms or applications which provide the option to download files. It isn’t necessary for simple static sites.

## CORS

[CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) or Cross-Origin Resource Sharing is a mechanism based on the HTTP headers that allow the server to respond from what origins the server can accept. The server can accept the request if it is being made from the same origin as the server but can reject requests from other origins or domains via [the same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy). All major browsers enforce this same-origin policy.

When the client requests the server, the server can respond with the following headers indicating that the request from the client or domain is allowed:

```bash
Access-Control-Allow-Origin: https://www.website.com
```

The server can also respond with a wildcard if requests from all domains are allowed:

```bash
Access-Control-Allow-Origin: \*
```

It is also important to note here that if a request fails due to CORS, the details of the error are only visible in the browser’s console. CORS also doesn’t provide any protection against [CSRF](https://developer.mozilla.org/en-US/docs/Glossary/CSRF) (Cross-Site Request Forgery) attacks.

## Same-origin policy

[The same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) is a security mechanism that limits the ability of a document from one origin to interact with the resources present in a different origin. This security measure was taken to ensure that data from one domain can’t be stolen from another.

It should also be noted that any domain can request a resource from another domain, but they can’t access the response unless the response uses the correct CORS header.

## Prevention of CORS errors

Errors arising due to CORS can be prevented by using the correct configurations. You should always try to use wildcard or null in the CORS headers and allow requests from only trusted domains.

CSP is a protocol that can be used to provide an additional level of security over various issues like XSS, data injection, etc. The same-origin policy is a security mechanism that limits the ability of a document from one origin to interact with the resources present in a different origin. This security measure was taken to ensure that data from one domain can’t be stolen from another.

Security

Imagine that you are working on an extensive application that releases new versions of an API every day. A lot of other applications depend on your API for their features to work as expected. When a bug gets released in your API, all the applications that rely on your API will stop working. Maintaining uptime for any application is essential, and having downtime because of the bug will cause many problems. One way to resolve this problem is by version control.

A good versioning strategy will ensure that at least one version of your API will work as expected. Because of this, the applications using the buggy version can fall back to a previous version.

Generally, version control is maintained in a changelog which the consumers of an API can refer to. Versioning can be breaking and non-breaking.

## Different types of versioning strategies

1. **URI versioning:** This is the most common versioning strategy, although it violates every URI should contain a unique resource. When a URI version is done, all the resources get updated to a new version. URI versioning can also cause issues with caching. An example of this strategy is the following:

    ```bash
    https://website.com/api/v1/users
    https://website.com/api/v2/users
    ```

2. **Query parameters versioning:** This strategy states the version of an API by using query parameters. An example of this kind of strategy can be the following:

    ```bash
    https://website.com/users?version=1
    ```

3. **Custom headers versioning:** Versioning can also be done by passing custom request headers. An example will be the following:

    ```bash
    curl -H "accept-version: 1" https://website.com/users
    ```

A good versioning strategy will ensure that at least one version of your API will work as expected. Because of this, the applications using the buggy version can fall back to a previous version. Generally, version control is maintained in a changelog which the consumers of an API can refer to. Versioning can be breaking and non-breaking.

Versioning

GraphQL is a query language for APIs and a runtime for fetching data from the server. In this guide, you will learn about GraphQL APIs.

Learn GraphQL APIs

[GraphQL](https://graphql.org/) is a query language for APIs and a runtime for fetching data from the server. In simple terms, it is a way of fetching only the data that you need from the server. It solves the problem of over-fetching and under-fetching of data.

At the end of this guide, you will know the following:

-   What is GraphQL?
-   What is Schema Definition Language (or SDL)?
-   What are the different GraphQL operations?

GraphQL is a query language for APIs and a runtime for fetching data from the server. In this guide, you will learn about GraphQL APIs. In this guide, you will learn about GraphQL and how you can use GraphQL in your application.

[GraphQL](https://graphql.org/) is a query language that lets your client request the server to send only the required data - nothing more and nothing less.

Let's say you are building a blogging platform. You will need to fetch the blog post, the author, and the published date. In traditional REST APIs, you can design this API very easily. Now, let's say you need to show the blog post's comments only for the web app. For your mobile app, you will have to configure your server to send the API response without the comments - which is unmaintainable.

This is where GraphQL can help you. Your client can ask for the data they need, and the server will return with only that data.

In the case of the mentioned scenario, your web app can ask the server to send the blog post, the author, the published date, and the comments. But your mobile app can ask for everything apart from the comments. In both these cases, the server will respond with exactly the data requested by the client.

Click on the "Fetch user details" button in the component below to fetch data from a GraphQL server.

<GraphQLAPI />

GraphQL is a query language that lets your client request the server to send only the required data – nothing more and nothing less.

What is GraphQL?

Schema Definition Language is nothing but the syntax of writing schemas in GraphQL query language, and it's pretty intuitive.

Consider the `User` schema below written in Schema Definition Language:

```graphql
type User {
	name: String!
	email: String!
}
```

The `User` type has two fields, `name` and `email` with type `String`.

<Callout>

The exclamation mark (`!`) depicts that the fields are _required_.

</Callout>

Schema Definition Language allows you to establish relationships between types. For example, a `Blog` is associated with a particular `User`.

```graphql
type User {
	name: String!
	email: String!
	blogs: [Blog!]!
}

type Blog {
	author: User!
}
```

Click on the 'Add "name" field' button in the component below to construct the syntax of a simple blog application.

<GraphQLSDL />

Schema Definition Language or SDL is nothing but the syntax of writing schemas in GraphQL query language, and it’s pretty intuitive.

What is Schema Definition Language (or SDL)?

### Queries

When requesting data from a GraphQL server, the client has to send some information to the server. Based on this information, the server will send the response. This information is known as a "query".

Click on the 'Fetch user' button in the component below to make your first GraphQL query.

<GraphQLAPI type="query" />

### Mutations

When you want to save data to a GraphQL server, you can use a "mutation". You can create, update, and delete data from a GraphQL server using mutations.

Click on the 'Create user' button in the component below to make your first GraphQL mutation.

<GraphQLAPI type="mutation" />

When requesting data from a GraphQL server, the client has to send some information to the server. Based on this information, the server will send the response. This information is known as a “query”.

What are the different GraphQL operations?

AsyncAPI is an Open Source initiative that exists to improve Event-Driven Architectures.

Learn AsyncAPI

At the end of this guide, you will know the following:

-   What is Event-Driven Architecture?
-   What is AsyncAPI?
-   What are the different parts of AsyncAPI?

AsyncAPI is an Open Source initiative that exists to improve Event-Driven Architecture. In this guide, you will learn about AsyncAPI and how you can use AsyncAPI in your application.

## What is Event-Driven Architecture?

In an Event-Driven Architecture, a system reacts to an event and sends an acknowledgment. In this type of architecture, a system generally sends a response when an event occurs.

An Event-Driven Architecture contains the following parts:

| Name           | Description                                                                                                               |
| -------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Publisher      | The application that sends the message                                                                                    |
| Message broker | An intermediate infrastructure responsible for facilitating the sending of a message from the Publisher to the Subscriber |
| Subscriber     | The application that receives the message sent by the Publisher                                                           |
| Message        | A piece of information that is sent to all the interested Subscribers from a Publisher via the Message broker             |
| Channels       | The Message broker sends the message to the Subscribers via multiple channels                                             |

In an Event-Driven Architecture, a system reacts to an event and sends an acknowledgment. In this type of architecture, a system generally sends a response when an event occurs.

What is Event-Driven Architecture?

## What is AsyncAPI?

AsyncAPIs work on the principle of Event-Driven Architecture (EDA). In AsyncAPIs, multiple Subscribers can subscribe to a Publisher. When an event occurs, the Publisher can notify all the Subscribers via the Message broker.

<AnatomyOfAsyncAPIRequest />

## Example of an AsyncAPI

The following component shows an example of how an AsyncAPI works.

<AnatomyOfAsyncAPI />

AsyncAPIs work on the principle of Event-Driven Architecture (EDA). In AsyncAPIs, multiple Subscribers can subscribe to a Publisher. When an event occurs, the Publisher can notify all the Subscribers via the Message broker.

What is an AsyncAPI?

SOAP (Simple Object Access Protocol) is an XML-based messaging protocol for transferring information.

Learn SOAP APIs

At the end of this guide, you will know the following:

-   What are SOAP APIs?
-   What are the different parts of SOAP APIs?

SOAP is a messaging protocol for transferring information via the internet. SOAP uses XML for exchanging messages.

## What is a SOAP API?

SOAP is a messaging protocol for transferring information via the internet. SOAP uses [XML](https://developer.mozilla.org/en-US/docs/Web/XML/XML_introduction) for exchanging messages.

A SOAP message is an XML document containing the following parts:

| Name     | Description                                                               | Mandatory |
| -------- | ------------------------------------------------------------------------- | --------- |
| Envelope | The start and the end of the message                                      | Yes       |
| Header   | The optional attributes of the message used in processing the message     | No        |
| Body     | The data comprising the message being sent                                | Yes       |
| Fault    | Provides information about errors that occur while processing the message | No        |

<AnatomyOfSOAPMessage />

## Example of a SOAP API

The following component shows an example of what a SOAP API request and response looks like. Click on the **Send request** button in the component below to understand the syntax of a SOAP API request and response.

<AnatomyOfSOAPRequest />

What is a SOAP API?

In this guide, you will learn about RapidAPI Hub and its use in your application.

Learn RapidAPI Hub (Consumer)

Imagine that you are building an e-commerce application. You will need to build the infrastructure necessary to support a payment processing gateway, authentication, search, etc. It becomes challenging to develop and maintain the required infrastructure to support all these systems.

You can resolve this issue by using different API providers who provide APIs for all these components. [RapidAPI Hub](https://RapidAPI.com/hub) can help you with that.

## About this course

This course is an interactive one that will guide you through understanding RapidAPI Hub and how to use its APIs in your application.

You can go through the interactive component below to understand the steps for integrating an API from [RapidAPI Hub](https://RapidAPI.com/hub).

<RapidAPIConsumer />

You can resolve the challenges associated with developing and maintaining complex API issues by using different API providers who provide APIs for all these components. RapidAPI Hub can help you with that. In this guide, you will learn about RapidAPI Hub and its use in your application.

Learn RapidAPI Hub as a Consumer

[RapidAPI Hub](https://RapidAPI.com/hub) is the world's largest API hub, with over 3 million developers accessing more than 30,000 APIs. You can find APIs for all these components from RapidAPI Hub.

RapidAPI Hub provides various features like **Discovery**, **Integration**, and **Consumption Management** to make it very easy to integrate any API from RapidAPI Hub into your application.

<Callout>
	RapidAPI provides code snippets in 20 programming languages with support for
	40 libraries.
</Callout>

To use an API from [RapidAPI Hub](https://RapidAPI.com/hub), you will need to [create an account](https://RapidAPI.com/auth/sign-up). Some of the APIs that are available on RapidAPI Hub offer freemium plans. So, you can try them out without adding your credit card details.

## Create a free RapidAPI account

You will need to [create an account](https://RapidAPI.com/auth/sign-up) to test our APIs, integrate them into your applications, and track the analytics. You can create an account by [visiting this page](https://rapidapi.com/auth/sign-up).

You can choose to sign up using your Google, Github, Facebook account or by manually entering your username, work email and password.

## Find APIs that match your requirements

You can search for any kind of API in RapidAPI Hub. However, if you are unsure about the type of API you are looking for, you can filter our categories or collections. You can also use our advanced search to find your desired API.

![Find APIs that match your requirements](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image1.png)

### Categories

Categories are a way to organize the APIs. When a new API is added to RapidAPI Hub, a category is added to help others find that API. In RapidAPI Hub, you will find various categories like [Data](https://RapidAPI.com/category/Data), [Sports](https://RapidAPI.com/category/Sports), [Finance](https://RapidAPI.com/category/Finance), [Travel](https://RapidAPI.com/category/Travel), [Entertainment](https://RapidAPI.com/category/Entertainment), etc. You can also view all the APIs that belong to a particular category and search inside it.

### Collections

A collection is a list of APIs with similar characteristics like [Top Meme APIs](https://RapidAPI.com/collection/meme), [Top Geocoding and Location APIs](https://RapidAPI.com/collection/geocoding-location-apis), etc. An API can belong to multiple collections, and the RapidAPI team manages collections on RapidAPI Hub. You can also view all the APIs that belong to a particular collection and search inside it.

### Advanced search

You can also use [our advanced search functionality](https://RapidAPI.com/search/weather) to filter APIs based on categories, collections, verified, official, GraphQL, and Kafka API types.

![Advanced search](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image2.png)

<Quiz
	question="In RapidAPI Hub, you can use multiple APIs using a single API key?"
	options={[
		{
			label: 'Yes',
			isCorrect: true
		},
		{
			label: 'No',
			isCorrect: false
		}
	]}
/>

RapidAPI Hub is the world’s largest API hub, with over 3 million developers accessing more than 30,000 APIs. You can find APIs for all these components from RapidAPI Hub.

How can you use RapidAPI Hub?

For subscribing to an API, you will need to visit the pricing page of the API on [RapidAPI Hub](https://RapidAPI.com/hub) and select your desired subscription plan. Subscriptions are every month.

An API can also have free plans with hard or soft limits. The pricing page of an API will also show the monthly quota and the overage fee. An API can also have Rate Limits like **10 requests per minute**.

![Subscribing to an API](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image3.png)

For subscribing to an API, you will need to visit the pricing page of the API on RapidAPI Hub and select your desired subscription plan. Subscriptions are every month. An API can also have free plans with hard or soft limits. The pricing page of an API will also show the monthly quota and the overage fee.


Subscribing to an API

The usage of an API can be tracked via [the Developer Dashboard](https://RapidAPI.com/developer/dashboard). You can track all your APIs, apps, billing, API quota usage, and API analytics from the **Developer Dashboard**.

You can also add new apps and APIs from the Developer Dashboard.

![Developer Dashboard](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image4.png)

The usage of an API can be tracked via the Developer Dashboard. You can track all your APIs, apps, billing, API quota usage, and API analytics from the Developer Dashboard.


Developer Dashboard

You can go through the interactive component below to understand the steps for integrating an API from [RapidAPI Hub](https://RapidAPI.com/hub).

<RapidAPIConsumer />

Once you find the API you are looking for, you can visit that API's page on [RapidAPI Hub](https://RapidAPI.com/hub) and click on the **Subscribe to Test** button.

![Subscribe to Test button](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image5.png)

After you click on the button, you will need to choose a plan for the API. Click on the **Subscribe** button next to the plan that you want to use:

![Subscribe button](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image6.png)

<Callout>
	For Freemium and Paid APIs, you will have to enter credit card information.
	For Free APIs, the credit card information isn't required.
</Callout>

Once you have subscribed to an API, you can click on the **Endpoints** tab to view all the endpoints that the API provides:

![Endpoints tab](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image7.png)

Next, you can click on the **Test Endpoint** button for the endpoint that you want to test:

![Test Endpoint button](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image8.png)

When the API request is successful, you will be able to view the **Results** tab, which will render the **Body** of the response:

![Response Body](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image9.png)

Next, you can visit the **Code Snippets** tab and choose the appropriate language and library that you want to use:

![Code Snippets](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-consumer/images/image10.png)

<Callout>
	RapidAPI provides code snippets in 20 programming languages with support for
	40 libraries.
</Callout>

Next, you can copy and paste the code into your application, and it will just work.

<Callout>

If you are libraries for fetching data like [Axios](https://www.npmjs.com/package/axios), you will need to install them separately in your application.

</Callout>

You can easily search and integrate an API for the RapidAPI Hub into your application. In this lesson, you will learn about how to integrate a RapidAPI Hub’s API.

Integrate a RapidAPI Hub&#8217;s API

In this guide, you will learn about how to add an API to RapidAPI.

Learn RapidAPI Hub (Provider)

<Callout>

Building your API and listing it on [RapidAPI](https://RapidAPI.com/hub) will put it in front of over 3 million developers.

</Callout>

## About this course

This course is an interactive one that will guide you through understanding how you can add your API to RapidAPI.

You can go through the interactive component below to understand how much you can earn by publishing an API on [RapidAPI Hub](https://RapidAPI.com/hub).

<RapidAPIPricing />

Building your API and listing it on RapidAPI will put it in front of over 3 million developers. In this guide, you will learn about how to add an API to RapidAPI. This guide is an interactive one that will guide you through understanding how you can add your API to RapidAPI.

Learn RapidAPI Hub as a Provider

Other developers can build their applications using the API that you have built and provided in RapidAPI. You can also generate income by providing a pricing plan for your API.

RapidAPI makes it very easy for you to manage your APIs. You can concentrate on building your APIs, and RapidAPI will take care of the rest - monitoring your APIs, latency, and error rates.

RapidAPI also provides your services like user management and billing that are difficult to set up and manage.

Other developers can build their applications using the API that you have built and provided in RapidAPI. You can also generate income by providing a pricing plan for your API. RapidAPI makes it very easy for you to manage your APIs. You can concentrate on building your APIs, and RapidAPI will take care of the rest – monitoring your APIs, latency, and error rates.

Why should you provide your API inside RapidAPI?

To add an API to [RapidAPI](https://RapidAPI.com/hub), you will need to [create an account](https://RapidAPI.com/auth/sign-up) first.

In this module, you will learn how to list your API in RapidAPI and put it in front of over 3 million developers.

To add a new API to RapidAPI, visit the [Provider Dashboard](https://provider.rapidapi.com/) and click on the **Add New API** button:

![The Add New API button](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image1.png)

You can provide the details like the **API Name**, **Short Description** (that appears in search) and **Category** of your API:

![Add API details](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image2.png)

<Callout>Each API belongs to a single category.</Callout>

<Quiz
	question="In RapidAPI, can an API belong to multiple categories?"
	options={[
		{
			label: 'Yes',
			isCorrect: false
		},
		{
			label: 'No',
			isCorrect: true
		}
	]}
/>

In this module, you will learn how to list your API in RapidAPI and put it in front of over 3 million developers.

How can you add an API to RapidAPI?

You can specify your API using the following options:

-   Kafka
-   Specifying a GraphQL Schema
-   Uploading a Postman Collection file
-   Create the spec using the RapidAPI UI
-   Automating the spec by uploading your OpenAPI file

You can select your preferred option and click on the **Add API** button to continue:

![Add API button](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image3.png)

In RapidAPI Hub, you can specify your API using various options like Kafka, specifying a GraphQL Schema, uploading a Postman Collection file, creating the spec using the RapidAPI UI, and automating the spec by uploading your OpenAPI file.

Specifying your API

Through the **Overview tab**, you can add more details like a **Long Description**, **Logo**, **Website**, and **Terms of Use** for your API:

![The Overview tab](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image4.png)

You can add more details like a long description, logo, website, and the terms of use for your API in RapidAPI.

Overview tab

From the **API Specs** tab, you can add the **Base URL** of your API.

![Add Base URL](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image5.png)

<Callout>

All the API endpoints are relative to the **Base URL**.

</Callout>

You click on the **Configure** button to enter the Base URL and click on the **Save** button:

![Enter the Base URL](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image6.png)

You can add specifications for your APIs in RapidAPI. In this lesson, you will learn about how to add an API spec to RapidAPI Hub.

Add API specs

RapidAPI allows you to **create versions for your APIs**. You can choose to either update an existing version or create a new version.

To create a new version, you can select the **Add New Version** option from the **API Specs** dropdown:

![Add a new version for your APIs](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image9.png)

<Quiz
	question="In RapidAPI, you can add versions to your APIs?"
	options={[
		{
			label: 'Yes',
			isCorrect: true
		},
		{
			label: 'No',
			isCorrect: false
		}
	]}
/>

RapidAPI allows you to create versions for your APIs. You can choose to either update an existing version or create a new version.

Versioning your APIs

You can create endpoints for your APIs by selecting the **Endpoints** tab:

![Defining endpoints for your APIs](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image10.png)

There are two ways of defining your endpoints:

-   REST
-   GraphQL

If you click on the **Create REST Endpoint**, you will be able to add the Name, Description, External Doc URL, and External Doc Description for the new endpoint.

![Providing details for the endpoint](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image11.png)

Next, you will also be able to select the HTTP method and path for your endpoint:

![Creating a REST API endpoint](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image12.png)

You can also provide the following details along with your endpoint:

-   **Headers:** You can specify custom headers that the consumer will have to send as a part of the request to the API endpoint.
-   **Query:** Passing a query string is often necessary to provide certain details like **offset** or **limit** for paginated queries.
-   **Body:** The **Body** can be sent only for `POST`, `PUT` and `PATCH` requests. You can select the expected type of **Body**.

You can also click on the **Test Endpoint** button to check your new endpoint:

![Testing the new endpoint](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image13.png)

You can also choose to create an example from the response by clicking on the **Create example from response** button:

![Creating example from the response of the new endpoint](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image14.png)

<Quiz
	question="In RapidAPI, can you use both REST and GraphQL APIs?"
	options={[
		{
			label: 'Yes',
			isCorrect: true
		},
		{
			label: 'No',
			isCorrect: false
		}
	]}
/>

You can create endpoints for your APIs in RapidAPI. You can specify custom headers, pass a query string and add a body for POST, PUT, and PATCH requests.

Defining endpoints for your APIs

RapidAPI allows you to add **secret headers and parameters** which are sent on every request but are hidden from the API consumers.

![Secret Headers and Parameters](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image8.png)

There are mainly two uses for secret headers and parameters:

-   You can use these hidden parameters to authenticate your API requests.
-   You can use secret headers and parameters to set environment variables.

<Callout>
	The API consumer doesn't need to add anything extra for the secret headers
	and parameters.
</Callout>

RapidAPI allows you to add secret headers and parameters which are sent on every request but are hidden from the API consumers.

Secret Headers &#038; Parameters

Security is critical to any business. Securing the APIs that you provide will ensure that the consumers of your APIs can run their applications properly. By securing your APIs, you can inspire confidence for your API consumers.

[RapidAPI](https://RapidAPI.com/hub) provides various tools to safeguard your APIs. Some of them include:

-   Access control
-   Firewall settings
-   Threat Protection
-   Request schema validation

In this module, you will learn how to secure your APIs on RapidAPI.

Security is critical to any business. Securing the APIs that you provide will ensure that the consumers of your APIs can run their applications properly. By securing your APIs, you can inspire confidence in your API consumers. In this module, you will learn how to secure your APIs on RapidAPI.

How can your secure your APIs?

RapidAPI implements a **single secret key per application** across all APIs to minimize friction in testing and implementing APIs. There are other ways to implement authentication for your APIs.

![Different ways of authenticating your APIs](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image7.png)

## Basic

**Basic Authentication** is a method in which the client has to pass the authentication credentials (a username and password) along with the request to the server via the **Authorization** header. The syntax looks like the following:

```json
Authorization: Basic <credentials>
```

The Base64 encoding of the username and password joined by a single colon `:` is passed in place of `credentials`. This is the simplest form of enforcing access control for API requests.

<Callout>

When the **Basic** authentication option is selected, the credentials (username and password) should be sent by the API consumer in the request header (in addition to the `X-RapidAPI-Key` header) while making requests to the API.

</Callout>

## Header

By using **Header authentication**, API providers can enforce API consumers to add one or more valid authentication-related headers to API requests.

If invalid credentials are passed, the API provider will respond with an unsuccessful response code. The API provider is responsible for verifying these values and returning the proper response to the API consumer.

## Query

**Query authentication** allows API providers to enforce API consumers to add one or more query string parameters to API requests.

If invalid values are passed, the API provider will respond with an unsuccessful response code. The API provider is responsible for verifying these values and returning the proper response to the API consumer.

## OAuth2

**[OAuth2](https://oauth.net/2/)** is the industry-standard protocol for token-based authorization. API providers can authorize only certain capabilities (or scopes) for their APIs. RapidAPI supports two OAuth Grant Types:

-   Client Credentials
-   Authorization Code

<Quiz
	question="In RapidAPI, can you have fine-grained access control for your APIs?"
	options={[
		{
			label: 'Yes',
			isCorrect: true
		},
		{
			label: 'No',
			isCorrect: false
		}
	]}
/>

RapidAPI implements a single secret key per application across all APIs to minimize friction in testing and implementing APIs. There are other ways to implement authentication for your APIs.

Access control

RapidAPI also provides various options to secure your API endpoints.

## Firewall Settings

RapidAPI adds a unique `X-RapidAPI-Proxy-Secret` header on every API request. This header has a unique value for every API, and if the value is invalid (missing or different), it can be assumed that it isn't coming from the RapidAPI infrastructure.

![Firewall Settings](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image15.png)

## Threat Protection

Threat protection **protects your API from SQL or Javascript injection attacks**. This protection is optional and is left to the provider to enable or disable.

When enabled, the `Content-Type` header must be specified if the request has a body. If the `Content-Type` header is not specified, the request will be blocked.

![Threat Protection](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image16.png)

## Request Schema Validation

If enabled, RapidAPI will automatically validate a bunch of parameters like path, query, and header during run time and block all invalid requests. This requires a `Content-Type` header in requests with a body.

![Request Schema Validation](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image17.png)

## Request Configurations

### Request Size Limit

This is the maximum allowed size of a request.

**It can be less than or equal to 50 MB**, which is the default value. If left empty or configured as 0, the default value is applied. The request size includes the request line, header, and request body.

### Proxy Timeout Setting

This is the maximum allowed time for the RapidAPI Gateway to wait for a response.

**It can be less than or equal to 180 seconds**, which is the default value. If left empty or configured as 0, the default value is applied.

![Request Configurations](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image18.png)

RapidAPI also provides various options to secure your API endpoints. RapidAPI adds a unique “X-RapidAPI-Proxy-Secret” header on every API request. This header has a unique value for every API, and if the value is invalid (missing or different), it can be assumed that it isn’t coming from the RapidAPI infrastructure.


Once you build your APIs, you will need a way to manage them.

[RapidAPI Hub](https://RapidAPI.com/hub) provides you with various tools to help you manage your APIs. Some of them are:

-   Adding plans and pricing for your APIs
-   Modifying Gateway DNS settings
-   Inviting developers even to your private APIs
-   Creating documentation for your APIs
-   A place to announce changes and modifications to your APIs

In this module, you will learn how to manage your APIs on RapidAPI.

RapidAPI Hub provides you with various tools to help you manage your APIs. In this module, you will learn how to manage your APIs on RapidAPI.

How can you manage your APIs on RapidAPI?

RapidAPI provides you the flexibility to choose your pricing plan. All APIs on RapidAPI fall into one of four categories:

| Category    | Description                                                                                                                    |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------ |
| Free        | APIs that do not require a credit card or subscription to consume.                                                             |
| Pay Per Use | APIs that don't have a subscription fee associated with the. A credit card is required as you pay for what you use on the API. |
| Freemium    | Paid APIs that also include a limited free tier. These require a credit card, even for the free plan.                          |
| Paid        | APIs that require a paid subscription plan and credit card to consume.                                                         |

You can go through the interactive component below to understand how much you can earn by publishing an API on [RapidAPI Hub](https://RapidAPI.com/hub?utm_source=RapidAPI.com/learn&utm_medium=DevRel&utm_campaign=DevRel).

<RapidAPIPricing />

## Pricing Attributes

You can define objects to set quotas and specify charges per object. You can add objects or features to your plan.

![Pricing Attributes](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image23.png)

## Public & Private Plans

You can have up to four different pricing plans. To add a new plan, you can click the **Add Plan** button.

![Public & Private Plans](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image24.png)

RapidAPI provides you the flexibility to choose your pricing plan. You can define objects to set quotas and specify charges per object. You can add objects or features to your plan.

Plans &#038; Pricing

From the **Global Settings** tab, it is possible to:

-   Modify the **Gateway DNS**.
-   **Invite Developers** to view and consume your API even though it is private.

![Global Settings](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image21.png)

There is another section inside this tab through why it is possible to:

-   **Change the visibility** of your API.
-   **Transfer the ownership** of this API to another RapidAPI user.
-   **Permanently delete** this API.

![Danger Section](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image22.png)

You can modify the Gateway DNS or invite developers to view and consume your API even though it is private.

Global Settings

The **Docs** tab can be used to highlight your API's features:

![Docs tab](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image19.png)

The **Announcements** tab can be used to send emails to all your API consumers and notify them of an **update**, a **new pricing plan**, or other important information about your API:

![Announcements tab](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-hub-provider/images/image20.png)

Docs can be used to highlight your API’s features. Announcements can be used to send emails to all your API consumers and notify them of an update a new pricing plan, or other important information about your API.

Docs and Announcements

In this guide, you will learn about what RapidAPI Testing is and how you can use it to create and manage tests for your APIs.

Learn RapidAPI Testing

With RapidAPI Testing, you can create tests intuitively via drag and drop. You have granular control over these tests. These tests can also run across global data centers.

RapidAPI Testings seamlessly integrates with RapidAPI Hub without any additional overhead. You can also run tests on your CI/CD pipeline.

You can go through the interactive component below to understand how [RapidAPI Testing](https://RapidAPI.com/testing/dashboard) can help you write tests for your APIs.

<RapidAPITesting />

To create a new test, you will need to add an API to [RapidAPI](https://RapidAPI.com/hub). You will need to [create an account](https://RapidAPI.com/auth/sign-up) first.

<Callout
	title="Deep dive"
	linkText="Read more"
	linkHref="https://rapidapi.com/learn/hub/provider"
>
	Learn more about how to add an API to RapidAPI Hub.
</Callout>

Visit the [RapidAPI Testing dashboard](https://rapidapi.com/testing) to see all your APIs.

![RapidAPI Testing dashboard](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image1.png)

Select the API that you want to test by clicking on it.

![Tests for a single API](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image2.png)

Click on the "Create Test" button and add a name to your test. You will be redirected to the page from where you can create the tests.

![Tests generator for APIs](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image3.png)

Select an endpoint that you want to test and click on the "Send Request" button.

![Testing an endpoint](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image4.png)

Click on the "Add to test" button to add the response to the test.

![Selecting a request for testing](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image5.png)

You can select the assertions that should be included in the test. Once you are done selecting the assertions, click on the "OK" button.

![Selecting the assertions to be included in the test](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image6.png)

You will be able to view the assertions now.

![List of the selected assertions](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image7.png)

Click on the "Save & Run" button to run the assertions. You should be able to view the latest assertion inside the "RECENT RESULTS" tab.

![List of the latest assertions](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image8.png)

If oy click on the result, you will be able to view the details.

![Details of the latest assertion](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image9.png)

RapidAPI offers a selection of action presets from which you can choose to add to your tests.

![List of action presets](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image10.png)

To create a new test, you will need to add an API to RapidAPI. You will need to create an account on RapidAPI first.

Getting started

You can also schedule your tests to run at regular intervals. To schedule tests, click on the "Schedule" link on the sidebar.

![The "Schedule" link on the sidebar](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image11.png)

Next, click on the "Add Schedule" button and select the Frequency, Environment, and Locations where the tests should run.

![Settings for scheduling tests](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image12.png)

Click the "Submit" button to schedule the tests. Once the tests run is complete, it will show up in the "RECENT RESULTS" tab.

![List of recent tests](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image13.png)

You can also schedule your tests in RapidAPI Testing to run at regular intervals. In this lesson, you will learn about how to schedule the tests in RapidAPI Testing.

Scheduling tests

From the "Analytics" tab, you can view a snapshot of all runs of your test. This will give you a quick overview of the number of successful and failed runs for a particular test.

![Snapshot of all runs for a single test](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image14.png)

You can also sort and filter the results of all the runs for your test from the "Results" tab. You can sort and filter between successful and failed test runs.

![Results of all runs for a single test](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image15.png)

RapidAPI Testing gives you a snapshot of all runs of your test. This will give you a quick overview of the number of successful and failed runs for a particular test. In this lesson, you will learn about how to monitor your tests inside RapidAPI Testing.

Monitoring your tests

<Callout>

[RapidAPI Client](https://rapidapi.com/products/api-design) is an API developer tool with an intuitive UI that simplifies your API and interacts with HTTP APIs. It supports REST, SOAP, and GraphQL.

</Callout>

You will need to [create an account](https://paw.app/signup) before you can use RapidAPI Client.

## Creating a project

Once you sign up for [RapidAPI Client](https://paw.app), click on the "Create New Project" button to create a new project.

![The "Create new Project" button](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image16.png)

Enter the "Project Name", select team, and click on the "Create Project" button to create a new project in RapidAPI Client.

![Creating a new project](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image17.png)

## Creating a new request

Once you are in your new project, click on the "+" (plus) icon to create a new request.

![Creating a new request](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image18.png)

Enter the request URL and click on the "Send" button to send a new request. Once your request is completed, you will see the response on the right.

![Viewing the response from a new request](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image19.png)

The **GET**, **HEAD**, **POST**, **PUT**, **PATCH**, **DELETE**, **TRACE**, and **OPTIONS** HTTP methods are supported by RapidAPI Client.

You can also add headers to your request as per your requirements.

![Adding headers for a request](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image20.png)

Like headers, you can also send query parameters, body, and authentication headers along with your request.

RapidAPI Client generates code snippets for your request so that you can copy and paste them into your code, enhancing the development experience.

![Code snippets generation for a request](https://raw.githubusercontent.com/RapidAPI/DevRel-Stack-Data/production/learn/posts/rapidapi-testing/images/image21.png)

The code snippet updates as you modify your request.

RapidAPI Client is an API developer tool with an intuitive UI that simplifies your API and interacts with HTTP APIs. It supports REST, SOAP, and GraphQL.