
# Availability

The Availability resources allow you to interact with the availability options of your items and stores.

The following table describes the different contents of the Availability resources:


NEW Rest API of Availability

Integration Requirements

Getting Started

API Endpoints

Utils Endpoints

Domains

New Domains

Contents of the guide

POST integrations login

POST utils login

Authentication

GET menu

POST menu

GET menu/approved/{storeId}

GET menu/rappi/{storeId}

Menus

GET orders

GET orders status sent

PUT orders/{orderId}/take/{cookingTime}

PUT orders/{orderId}/reject

POST orders/{orderId}/ready-for-pickup

GET orders/{orderId}/events

Orders

GET stores-pa

PUT store-pa integrated status

GET store current menu

GET stores-pa check in code

Stores

POST availability/items/status

POST availability/items/rappi/status

PUT availability/stores/items

PUT availability/stores/items/rappi

POST availability/stores

PUT availability/stores

PUT availability/stores/enable/massive

PUT availability/stores/enable

Availability

GET webhook

PUT webhook Add Stores

PUT webhook Change Url

POST webhook

DELETE webhook

PUT webhook reset secret

PUT webhook change status

Webhooks

GET corridor/store/{storeId}

GET corridor/schedule/{corridorId}/store/{storeId}

POST corridor/schedule/{corridorId}/store/{storeId}

PUT corridor/schedule/{corridorId}/store/{storeId}

DELETE corridor/schedule/{corridorId}/store/{storeId}/{corridorProductScheduleId}

Corridor schedules by store ID

GET corridor/integration/{integrationId}

GET corridor/schedule/{corridorId}/integration/{integrationId}

POST corridor/schedule/{corridorId}/integration/{integrationId}

DELETE corridor/schedule/{corridorId}/integration/{integrationId}/{corridorProductScheduleId}

Corridor schedules by integration

GET product/corridor/{corridorId}/store/{storeId}

GET product/schedule/{productId}/corridor/{corridorId}/store/{storeId}

POST product/schedule/{productId}/corridor/{corridorId}/store/{storeId}

PUT product/schedule/{productId}/corridor/{corridorId}/store/{storeId}

DELETE product/schedule/{productId}/corridor/{corridorId}/store/{storeId}/{corridorProductScheduleId}

Product schedules by product ID

GET sku/corridor/{corridorId}/integration/{integrationId}

GET sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}

POST sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}

PUT sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}

DELETE sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}/{corridorProductScheduleId}

Product schedules by SKU

GET store/schedule/{storeId}

GET store/schedule/{storeId}/holiday

GET store/schedule/{storeId}/special

POST store/schedule/{storeId}

POST store/schedule/{storeId}/holiday/{holidayDayId}

POST store/schedule/{storeId}/special

POST store/schedule/{storeId}/special/{specialDayId}

PUT store/schedule/{storeId}/{storeScheduleId}

DELETE store/schedule/{storeId}/{storeScheduleId}

DELETE store/schedule/{storeId}/special/{specialDayId}

Store hours

GET menu/integration/{integrationId}

Products Status

PATCH Products availability by SKU or ID

POST Validate products availability by SKU or ID

PATCH Toppings availability by SKU or ID

POST Validate toppings availability by SKU or ID

PATCH Items availability by SKU or ID

POST Validate items availability by SKU or ID

NEW Rest API of Menu

GET stores/{storeId}/orders

GET orders/status/sent

PUT stores/{storeId}/orders/{orderId}/take

PUT stores/{storeId}/orders/{orderId}/cooking_time/{cookingTime}/take

GET stores/{storeId}/orders/{orderId}/handoff

POST stores/{storeId}/orders/{orderId}/bag-drink-confirmation

PUT stores/{storeId}/orders/{orderId}/cancel_type/{cancelType}/reject

NEW Rest API of Orders

GET payments

GET order_adjusments

GET charged_cancellations

GET store_adjustments

GET loans

GET debts

GET extras

GET taxes

GET compensations

GET cancellations

GET agreements

NEW Rest API of Financial

Getting StartedThis page explains how developers can get started using Rappi APIs for Restaurants Integration.Integration RequirementsSince integrating with our API requires direct contact with our team, follow these steps to get started.1. Initial ContactTo know the steps to sign up as a Rappi ally, contact your main Rappi point of contact.2. Credential CreationOnce your request is approved, you will receive access credentials for our development environment.3. Documentation ReviewBefore starting development, we recommend reviewing the following resources:API reference documentationAuthentication guide4. Testing in the Developer EnvironmentAfter signing up as a Rappy ally, you receive your Rappi credentials that consist of the following:client\_idclient\_secretUse these Rappi Credentials to create your Access Token with the POST token/login/integrations.After generating your Access Token, you can start using the Rappi API.


After signing up as a Rappy ally, you receive your Rappi credentials that consist of the following:client\_secretclient\_id.POST token/login/integrationsUse these Rappi Credentials to create your Access Token with the After generating your Access Token, you can start using the Rappi API.


4. Testing in the Developer Environment

Before starting development, we recommend reviewing the following resources:Authentication guideAPI reference documentation


3. Documentation Review

Once your request is approved, you will receive access credentials for our development environment.


2. Credential Creation

To know the steps to sign up as a Rappi ally, contact your main Rappi point of contact.


1. Initial Contact

Since integrating with our API requires direct contact with our team, follow these steps to get started.


This page explains how developers can get started using Rappi APIs for Restaurants Integration.
NOTE
We are in the process of improving our public APIs, which is why we ask you to always be aware of our official documentation.


The following tables contains all the resources available to use with Utils API:                                                                                                                  | Return the list of products and toppings with status and their availability |         |GET menu/integration/{integrationId}                                       | Product Status                                                                             | Delete a special day                                                        |         |
| DELETE store/schedule/{storeId}/special/{specialDayId}                                                                                                                  | Delete a time slot                                                          |         |
|                                                                                           | DELETE store/schedule/{storeId}/{storeScheduleId}                                                                                                                        | Update a time slot                                                          |         |
|                                                                                           | PUT store/schedule/{storeId}/{storeScheduleId}                                                                                                         | Create a time slot on a store's special day                                 |         |
|                                                                                           | POST store/schedule/{storeId}/special/{specialDayId}                                                                                                                             | Create a special day for the store                                          |         |
|                                                                                           | POST store/schedule/{storeId}/special                                                                                                         | Create a time slot on a holiday                                             |         |
|                                                                                           | POST store/schedule/{storeId}/holiday/{holidayDayId}                                                                                                                                        | Create a time slot on a regular schedule day of the store                   |         |
|                                                                                           | POST store/schedule/{storeId}                                                                                                                          | Returns all the hours of the store's special days                           |         |
|                                                                                           | GET store/schedule/{storeId}/special                                                                                                                          | Returns all holiday hours                                                   |         |
|                                                                                           | GET store/schedule/{storeId}/holiday                                                                                                                                          | Returns all regular store hours                                             |         |
|                                                                                           | GET store/schedule/{storeId}                                         | Store hours | Delete product schedules for the corridor and store                         |         |
| DELETE sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}/{corridorProductScheduleId}                                   | Update product schedules for the corridor and store                         |         |
|                                                                                           | PUT sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}                                 | Create product schedules for the corridor and store                         |         |
|                                                                                           | POST sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}                                   | Returns the product schedules configured for the corridor and store         |         |
|                                                                                           | GET sku/schedule/{sku}/corridor/{corridorId}/integration/{integrationId}                                                               | Returns the collection of products for the corridor and store               |         |
|                                                                                           | GET sku/corridor/{corridorId}/integration/{integrationId}                   | Product Schedules by SKU            | Delete product schedules for the corridor and store                         |         |
| DELETE product/schedule/{productId}/corridor/{corridorId}/store/{storeId}/{corridorProductScheduleId}                                              | Update product schedules for the corridor and store                         |         |
|                                                                                           | PUT product/schedule/{productId}/corridor/{corridorId}/store/{storeId}                                            | Create product schedules for the corridor and store                         |         |
|                                                                                           | POST product/schedule/{productId}/corridor/{corridorId}/store/{storeId}                                              | Returns the product schedules configured for the corridor and store         |         |
|                                                                                           | GET product/schedule/{productId}/corridor/{corridorId}/store/{storeId}                                                                                      | Returns the collection of products for the corridor and store               |         |
|                                                                                           | GET product/corridor/{corridorId}/store/{storeId}                                 | Product Schedules          | Delete corridor schedules for the store                                     |         |
| DELETE corridor/schedule/{corridorId}/integration/{integrationId}/{corridorProductScheduleId}                                            | Update corridor schedules for the store                                     |         |
|                                                                                           | PUT corridor/schedule/{corridorId}/integration/{integrationId}                                          | Create corridor schedules for the store                                     |         |
|                                                                                           | POST corridor/schedule/{corridorId}/integration/{integrationId}                                            | Returns the corridor schedules configured for the store                     |         |
|                                                                                           | GET corridor/schedule/{corridorId}/integration/{integrationId}                                                                                       | Returns the collection of corridors for the store                           |         |
|                                                                                           | GET corridor/integration/{integrationId} | Corridor Schedules by Integration                                                 | Delete corridor schedules for the store                                     |         |
| DELETE corridor/schedule/{corridorId}/store/{storeId}/{corridorProductScheduleId}                                                                                   | Update corridor schedules for the store                                     |         |
|                                                                                           | PUT corridor/schedule/{corridorId}/store/{storeId}                                                                                 | Create corridor schedules for the store                                     |         |
|                                                                                           | POST corridor/schedule/{corridorId}/store/{storeId}                                                                                   | Returns the corridor schedules configured for the store                     |         |
|                                                                                           | GET corridor/schedule/{corridorId}/store/{storeId}                                                                                                                              | Returns the collection of corridors for the store                           |         |
|                                                                                           | GET corridor/store/{storeId}                               | Corridor Schedules |
| NEW                                                                                                                              | Use this endpoint to generate an access token for utils services            | POST /restaurants/auth/v1/token/login/utils                                       | Authentication| API Resource                                                                              | Endpoint                                                                                                                                                                                                                         | Endpoint Description                                                        |         |
| ----------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------- |
|


The following table contains all the resources available to use with our API:                                                                                              | Enables or disables the webhooks for a list of stores                                                  |         |PUT webhook/{event}/change-status                                                                                                | Restarts the secret and generates a new one for the authenticated client                               |         |
|                                                     | PUT webhook/{event}/reset-secret                                                                                                      | Deletes stores from your webhook                                                                       |         |
|                                                     | DELETE webhook/{event}/remove-stores                                                                                                                                | Creates a new webhook for a list of stores for the authenticated client                                |         |
|                                                     | POST webhook                                                                                                    | Change url from stores                                                                                 |         |
|                                                     | PUT webhook/{event}/change-url                                                                                                    | Add stores to a specific webhook event                                                                 |         |
|                                                     | PUT webhook/{event}/add-stores                                                                                                                          | Returns the webhooks configured for all the stores of the authenticated client                         |         |
|                                                     | GET webhook/{event}             | Webhooks                                                                                        | Manage store availability synchronously in the application                                             |         |
| PUT availability/stores/enable                                                                        | Manage store availability asynchronously in the application                                            |         |
|                                                     | PUT availability/stores/enable/massive                                                                                                      | Manage store availability in the application                                                           |         |
|                                                     | PUT availability/stores                                                                              | Manage item availability in the application by Item ID                                                 |         |
|                                                     | PUT availability/stores/items/rappi                                                                                          | Manage item availability in the application by Item SKU                                                |         |
|                                                     | PUT availability/stores/items                                                                            | Returns the availability of items by Item ID                                                           |         |
|                                                     | POST availability/items/rappi/status                                                                                        | Returns the availability of items by Item SKU                                                          |         |
|                                                     | POST availability/items/status     | Availability                                                                                              | Update a store to integrated or not integrated                                                         |         |
| PUT stores-pa/{storeId}/status                                                                                                                                | Returns the list of stores for the authenticated client                                                |         |
|                                                     | GET stores-pa                 | Stores |
| NEW | Use this endpoint to confirm the number of bags and if there are drinks outside the bags in the order. | POST /restaurants/orders/v1/stores/{storeId}/orders/{orderId}/bag-drink-confirmation |
|                                                     | NEW                                 | Use this endpoint to take an order so that the store can start preparing it.                           | GET /restaurants/orders/v1/stores/{storeId}/orders/{orderId}/handoff                                                                                                     | Returns the latest events from the orders                                                              |         |
|                                                     | GET orders/{orderId}/events                                                                               | Confirms that the order is ready for pickup                                                            |         |
|                                                     | POST orders/{orderId}/ready-for-pickup                                                                                                     | Rejects an order                                                                                       |         |
|                                                     | PUT orders/{orderId}/reject                                                                              | Takes an order to start preparing                                                                      |         |
|                                                     | PUT orders/{orderId}/take/{cookingTime}                                                         |         |
|                                                     | SENT                                                                                                              | Returns a list of new orders created in GET orders/status/sent                                                                                                                                      | Returns a list of new orders created                                                                   |         |
|                                                     | GET orders                 | Orders |
| NEW                         | Returns the availability of products and toppings by SKU or ID in the Rappi app                        | POST /restaurants/menu/v1/stores/{storeId}/items/{identityType}/stock/status |
|                                                     | NEW                               | Asynchronously manages the availability of products and toppings by SKU or ID in the Rappi app         | PATCH /restaurants/menu/v1/stores/{storeId}/items/{identityType}/stock |
|                                                     | NEW                   | Returns the availability of toppings by SKU or ID in the Rappi app                                     | POST /restaurants/menu/v1/stores/{storeId}/toppings/{identityType}/stock/status |
|                                                     | NEW                         | Asynchronously manages the availability of toppings by SKU or ID in the Rappi app                      | PATCH /restaurants/menu/v1/stores/{storeId}/toppings/{identityType}/stock |
|                                                     | NEW                   | Returns the availability of products by SKU or ID in the Rappi app                                     | POST /restaurants/menu/v1/stores/{storeId}/products/{identityType}/stock/status |
|                                                     | NEW                                 | Asynchronously manages the availability of products by SKU or ID in the Rappi app                      | PATCH /restaurants/menu/v1/stores/{storeId}/products/{identityType}/stock                                                                                                            | Returns the last menu created for a store                                                              |         |
|                                                     | GET menu/rappi/{storeId}                                                                                                      | Returns the current approval status of a menu                                                          |         |
|                                                     | GET menu/approved/{storeId}                                                                                                                                         | Creates or updates a menu in a store                                                                   |         |
|                                                     | POST menu                                                                                                                                           | Returns the collection of menus created by the authenticating ally                                     |         |
|                                                     | GET menu                   | Menus |
| NEW                                                                         | Use this endpoint to generate an access token for integrations services                                | POST /restaurants/auth/v1/token/login/integrations | Authentication| API Resource                                        | Endpoint                                                                                                                                                                                  | Endpoint Description                                                                                   |         |
| --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | ------- |
|


The Rappi API includes all the resources, endpoints, and methods that allow you to integrate with the Rappi app, as well as manage all your products, menus, orders, menu schedules, and product availability.


AuthenticationTo authenticate when making API requests to the Rappi API, you require an Access Token.The Rappi API uses a Bearer authentication scheme, as the HTTP authentication method for API requests.To make API requests, send the token in a customer header to interact with protected resources.Rappi uses the following scheme for the Bearer authentication:| Key               | Value                    |
| ----------------- | ------------------------ |
| x-authorization | Bearer: \<access\_token> |The following table describes the different contents of the Authentication resource:| Resource                                                       | Description                                                             | Observations |
| -------------------------------------------------------------- | ----------------------------------------------------------------------- | ------------ |
| POST v1/token/login/integrations | Use this endpoint to generate an access token for integrations services | \_New\_      |
| POST v1/token/login/utils               | Use this endpoint to generate an access token for utils services        | \_new\_      |POST integrations loginUse this endpoint to generate an access token. This token allows you to authenticate when making API requests for integrations.Endpoint URLUse the following URLs to make a request with this endpoint:URL: https://{NEW\_DOMAIN}/restaurants/auth/v1/token/login/integrations{NEW\_DOMAIN}: This is your new Rappi Country Domain. See the list of new Country Domains.Endpoint PropertiesThis resource has the following properties:|                 |        |
| --------------- | ------ |
| request body  | json |
| response body | json |ParametersThis endpoint does not permit additional parameters.Sample RequestThis is an example of an API request using this endpoint:POST https://api.dev.rappi.com/restaurants/auth/v1/token/login/integrationsThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes      |          | Requested | Description                              |
| --------------- | -------- | --------- | ---------------------------------------- |
| client\_id     | string | true    | Client Id of your Rappi Credentials.     |
| client\_secret | string | true    | Client Secret of your Rappi Credentials. |Status CodesThese are the possible status codes of the response for this endpoint:200 Success403 UnauthorizedSample ResponseThis is an example of the response:This table describes the objects contained in the response example:| Response Object |           | Object Description                       |
| --------------- | --------- | ---------------------------------------- |
| access\_token  | string  | Access token to access secure endpoints. |
| token\_type    | string  | Token type.                              |
| expires\_in    | integer | Token expiration time in seconds.        |POST utils loginUse this endpoint to generate an access token. This token allows you to authenticate when making API requests for utils.Endpoint URLUse the following URLs to make a request with this endpoint:URL: https://{NEW\_DOMAIN}/restaurants/auth/v1/token/login/utils{NEW\_DOMAIN}: This is your new Rappi Country Domain. See the list of new Country Domains.Endpoint PropertiesThis resource has the following properties:|                 |        |
| --------------- | ------ |
| request body  | json |
| response body | json |ParametersThis endpoint does not permit additional parameters.Sample RequestThis is an example of an API request using this endpoint:POST https://api.dev.rappi.com/restaurants/auth/v1/token/login/utilsThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes      |          | Requirement | Description                              |
| --------------- | -------- | ----------- | ---------------------------------------- |
| client\_id     | string | required  | Client Id of your Rappi Credentials.     |
| client\_secret | string | required  | Client Secret of your Rappi Credentials. |Status CodesThese are the possible status codes of the response for this endpoint:200 Success403 UnauthorizedSample ResponseThis is an example of the response:This table describes the objects contained in the response example:| Response Object |           | Object Description                       |
| --------------- | --------- | ---------------------------------------- |
| access\_token  | string  | Access token to access secure endpoints. |
| token\_type    | string  | Token type.                              |
| expires\_in    | integer | Token expiration time in seconds.        |


This is an example of the response:{
"access\_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpeyJhbGciOiJIUzI1NiIsInR5cCI6IkpeyJhbGciOiJIUzI1NiIsInR5cCI6Ikp",
"token\_type": "Bearer",
"expires\_in": 604798
}This table describes the objects contained in the response example: | Token expiration time in seconds.        |integer    | expires\_in  | Token type.                              |
| string    | token\_type  | Access token to access secure endpoints. |
| string  | access\_token| Response Object |           | Object Description                       |
| --------------- | --------- | ---------------------------------------- |
|


Sample Response

These are the possible status codes of the response for this endpoint: Success200


Status Codes

This is an example of an API request using this endpoint:POST https://api.dev.rappi.com/restaurants/auth/v1/token/login/utilsThis is an example of the request:{
"client\_id": "7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd",
"client\_secret": "40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW"
} of your request requires:JSONThis table describes the attributes that the   | Client Secret of your Rappi Credentials. |required | string | client\_secret  | Client Id of your Rappi Credentials.     |
| required | string     | client\_id| Attributes      |          | Requirement | Description                              |
| --------------- | -------- | ----------- | ---------------------------------------- |
| curl --location 'https://api.dev.rappi.com/restaurants/auth/v1/token/login/utils'&#x20;
\--header 'Content-Type: application/json'&#x20;
\--data
'{
"client\_id": "4jleVdIkQm3yeZsSeu57BgZGbqGJ50h9",
"client\_secret": "pulfNKGM-4SfsEJJukF9b-bgPFMOA4x92axJs5yzooyLRn5wMdLNRIg\_AP6o5LYq"
}'URL url = new URL("https://api.dev.rappi.com/restaurants/auth/v1/token/login/utils");HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setDoOutput(true);final String jsonInputString = "{\n" +
"   "client\_id":"7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd",\n" +
"   "client\_secret":"40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW"\n" +
"}";try (OutputStream os = connection.getOutputStream()) {
byte\[] input = jsonInputString.getBytes(StandardCharsets.UTF\_8);
os.write(input, 0, input.length);
}try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());import requestsurl = "https://api.dev.rappi.com/restaurants/auth/v1/token/login/utils"payload = "{ "client\_id":"7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd","&#x20;
""client\_secret":"40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW" }"
headers = { 'Content-Type': 'application/json' }response = requests.request("POST", url, headers=headers, data=payload)print(response.text.encode('utf8'))var https = require("https");var options = {
method: "POST",
hostname: "api.dev.rappi.com",
path: "/restaurants/auth/v1/token/login/utils?",
headers: {
"Content-Type": "application/json",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});var postData = JSON.stringify({
client\_id: "7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd",
client\_secret:
"40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW",
});req.write(postData);req.end();package mainimport (
"fmt"
"io/ioutil"
"net/http"
"strings"
)func main() {}


Sample Request

This endpoint does not permit additional parameters.


Parameters

This resource has the following properties: |json | response body |
| json  | request body|                 |        |
| --------------- | ------ |
|


Endpoint Properties

Use the following URLs to make a request with this endpoint:https://{NEW\_DOMAIN}/restaurants/auth/v1/token/login/utils: URL.See the list of new Country Domains: This is your new Rappi Country Domain. {NEW\_DOMAIN}
NOTE
For samples of API requests on this site, we use the Developer domain: https://api.dev.rappi.com
IMPORTANT:  Your access token has a validity of 1 week


Endpoint URL

Use this endpoint to generate an access token. This token allows you to authenticate when making API requests for utils.


This is an example of the response:{
"access\_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpeyJhbGciOiJIUzI1NiIsInR5cCI6IkpeyJhbGciOiJIUzI1NiIsInR5cCI6Ikp",
"token\_type": "Bearer",
"expires\_in": 86400
}This table describes the objects contained in the response example: | Token expiration time in seconds.        |integer    | expires\_in  | Token type.                              |
| string    | token\_type  | Access token to access secure endpoints. |
| string  | access\_token| Response Object |           | Object Description                       |
| --------------- | --------- | ---------------------------------------- |
|


This is an example of an API request using this endpoint:POST https://api.dev.rappi.com/restaurants/auth/v1/token/login/integrationsThis is an example of the request:{
"client\_id": "7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd",
"client\_secret": "40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW"
} of your request requires:JSONThis table describes the attributes that the     | Client Secret of your Rappi Credentials. |true | string | client\_secret    | Client Id of your Rappi Credentials.     |
| true | string     | client\_id| Attributes      |          | Requested | Description                              |
| --------------- | -------- | --------- | ---------------------------------------- |
| curl --location 'https://api.dev.rappi.com/restaurants/auth/v1/token/login/integrations'&#x20;
\--header 'Content-Type: application/json'&#x20;
\--data
'{
"client\_id": "4jleVdIkQm3yeZsSeu57BgZGbqGJ50h9",
"client\_secret": "pulfNKGM-4SfsEJJukF9b-bgPFMOA4x92axJs5yzooyLRn5wMdLNRIg\_AP6o5LYq"
}'URL url = new URL("https://api.dev.rappi.com/restaurants/auth/v1/token/login/integrations");HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setDoOutput(true);final String jsonInputString = "{\n" +
"   "client\_id":"7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd",\n" +
"   "client\_secret":"40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW"\n" +
"}";try (OutputStream os = connection.getOutputStream()) {
byte\[] input = jsonInputString.getBytes(StandardCharsets.UTF\_8);
os.write(input, 0, input.length);
}try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());import requestsurl = "https://api.dev.rappi.com/restaurants/auth/v1/token/login/integrations"payload = "{ "client\_id":"7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd","&#x20;
""client\_secret":"40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW" }"
headers = { 'Content-Type': 'application/json' }response = requests.request("POST", url, headers=headers, data=payload)print(response.text.encode('utf8'))var https = require("https");var options = {
method: "POST",
hostname: "api.dev.rappi.com",
path: "/restaurants/auth/v1/token/login/integrations?",
headers: {
"Content-Type": "application/json",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});var postData = JSON.stringify({
client\_id: "7iCfjZCO4bTns3OjqLK4de2GV3sp6Ymd",
client\_secret:
"40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW40iFFYJV9A1LrVmJsaIeARW",
});req.write(postData);req.end();package mainimport (
"fmt"
"io/ioutil"
"net/http"
"strings"
)func main() {}


Use the following URLs to make a request with this endpoint:https://{NEW\_DOMAIN}/restaurants/auth/v1/token/login/integrations: URL.See the list of new Country Domains: This is your new Rappi Country Domain. {NEW\_DOMAIN}
NOTE
For samples of API requests on this site, we use the Developer domain: https://api.dev.rappi.com
IMPORTANT:  Your access token has a validity of 1 week


Use this endpoint to generate an access token. This token allows you to authenticate when making API requests for integrations.


.Access TokenTo authenticate when making API requests to the Rappi API, you require an  scheme, as the HTTP authentication method for API requests.Bearer authenticationThe Rappi API uses a  to interact with protected resources.customer headerTo make API requests, send the token in a Rappi uses the following scheme for the Bearer authentication: |Bearer: \<access\_token> | x-authorization| Key               | Value                    |
| ----------------- | ------------------------ |
| The following table describes the different contents of the Authentication resource:      |new               | Use this endpoint to generate an access token for utils services        | POST v1/token/login/utils      |
| New | Use this endpoint to generate an access token for integrations services | POST v1/token/login/integrations| Resource                                                       | Description                                                             | Observations |
| -------------------------------------------------------------- | ----------------------------------------------------------------------- | ------------ |
|


This is an example of the response "Success 200":{
"storeId": "900111978",
"items": \[
{
"name": "Naked Cake con frutos",
"description": "Naked cake decorado con frutos. Cubierta de trufa derretida (ganache) y decorada con frutos del bosque.",
"sku": "8569874",
"type": "PRODUCT",
"price": 75.0,
"category": {
"id": "3",
"name": "Tortas",
"minQty": 0,
"maxQty": 0,
"sortingPosition": 0
},
"imageUrl": "https://image.com/image1.jpg",
"children": \[
{
"name": "Chocolate",
"description": "",
"sku": "8569874-159",
"type": "TOPPING",
"price": 0.0,
"category": {
"id": "1",
"name": "Sabor",
"minQty": 0,
"maxQty": 1,
"sortingPosition": 0
},
"imageUrl": "https://image.com/image10.jpg",
"children": \[],
"rappiIds": \["340948822"],
"sortingPosition": 1,
"maxLimit": 1
}
],
"rappiIds": \["2135527868"],
"sortingPosition": 0,
"maxLimit": 1
},
{
"name": "Snowman",
"description": "Linda lata de Snowman con productos variadosIncluye:Galletas mantequilla 350 gr, 6 brookies y 4 trufas de brownie.",
"sku": "856887",
"type": "PRODUCT",
"price": 75.0,
"category": {
"id": "9",
"name": "Navidad",
"minQty": 0,
"maxQty": 0,
"sortingPosition": 0
},
"imageUrl": "https://image.com/image2.jpg",
"children": \[],
"rappiIds": \["2135524472"],
"sortingPosition": 0,
"maxLimit": 1
}
]
}This is an example of the response "Invalid credentials 401":{
"message": "Not a valid token"
}Get Menu.The context of the attribute response were mentionend before in


This is an example of an API request using this endpoint:GET https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu/rappi/251This is an example of the request:final Integer storeId = 251;URL url = new URL(String.format("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu/rappi/%s", storeId));HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "GET",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/menu/rappi/251",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu/rappi/251"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("GET", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


This table contains the possible response codes for this endpoint: Success200


This resource has the following properties: |
| Authentication requirements | Token  |JSON|                             |        |
| --------------------------- | ------ |
| Response formats            |


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/menu/rappi/{storeId}: This is the identifier of your store integration.{storeId}See the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


Use this endpoint to return the last menu created for a specific store.


This endpoint returns a status response code only.401 Invalid Credentials:{
"message": "Not a valid token"
}


This is an example of an API request using this endpoint:GET https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu/approved/251This is an example of the request:final Integer storeId = 251;URL url = new URL(String.format("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu/approved/%s", storeId));HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "GET",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/menu/approved/251",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu/approved/251"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("GET", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/menu/approved/{storeId}See the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


Use this endpoint to return the approval status of a menu.


404 Store not found:{
"message": "StoreId 9001035324: not found associated Stores"
}This table describes the attributes from JSON response: | Store not found |stringmessage| Attributes             | Description     |
| ---------------------- | --------------- |
|


Sample response "404 Store not found"

401 Invalid Credentials:{
"message": "Not a valid token"
}This table describes the attributes from JSON response: | Not a valid token |stringmessage| Attributes             | Description       |
| ---------------------- | ----------------- |
|


Sample response "401 Invalid Credentials"

400 The menu structure is invalid:{
"message": "The submitted menu has errors.",
"errors": \[
{
"reason": "All items must have a valid name, category or product description.",
"relatedItems": \[
{
"description": "",
"sku": "product1",
"type": "PRODUCT",
"price": 899.0,
"category": {
"id": "455",
"name": "producto category name 1",
"minQty": 0,
"maxQty": 0,
"sortingPosition": 0
},
"imageUrl": "https://anydomain/anyimagen\_1.png",
"rappiIds": \["1965855"],
"sortingPosition": 0,
"maxLimit": 1
}
]
},
{
"reason": "Invalid urls were found",
"relatedItems": \[
{
"name": "producto name 1",
"description": "",
"sku": "product2",
"type": "PRODUCT",
"price": 899.0,
"category": {
"id": "455",
"name": "producto category name 1",
"minQty": 0,
"maxQty": 0,
"sortingPosition": 0
},
"imageUrl": "httpaas://anydomain/anyimagen\_2.png",
"rappiIds": \["1965855"],
"sortingPosition": 0,
"maxLimit": 1
}
]
}
]
}This table describes the attributes from JSON response: | Items with error.                                                                                   |array of objectserrors.relatedItems                 | Description of the error. you can find more info in "Validations on the Received menu"              |
| stringerrors.reason              | Error list found in menu.                                                                           |
| array of objectserrors                       | Generic error message to response "structure is invalid." message: "The submitted menu has errors." |
| stringmessage| Attributes                                   | Description                                                                                         |
| -------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| VALIDATIONS ON THE RECEIVED MENU.You can see the list of structure validations in the


Sample response "400 The menu structure is invalid"

This endpoint returns only one successful response code.


Sample response "200 success"

This is an example of an API request using this endpoint:POST https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menuThis is an example of the request:{
"storeId": "900103361",
"items": \[
{
"category": {
"id": "2090019638",
"maxQty": 0,
"minQty": 0,
"name": "Burgers",
"sortingPosition": 0
},
"children": \[
{
"category": {
"id": "211",
"maxQty": 1,
"minQty": 0,
"name": "Do you want to add?",
"sortingPosition": 0
},
"children": \[],
"name": "French Fries",
"price": 5000,
"sku": "2135092195",
"sortingPosition": 1,
"type": "TOPPING",
"maxLimit": 1
},
{
"category": {
"id": "211",
"maxQty": 1,
"minQty": 0,
"name": "Do you want to add?",
"sortingPosition": 0
},
"children": \[],
"name": "Potato Wedges",
"price": 7000,
"sku": "2135092196",
"sortingPosition": 1,
"type": "TOPPING",
"maxLimit": 1
}
],
"name": "Grilled Chicken Burger",
"price": 14000,
"sku": "2135092197",
"sortingPosition": 0,
"type": "PRODUCT",
"combo": true
},
{
"category": {
"id": "2090019639",
"maxQty": 0,
"minQty": 0,
"name": "Pizzas",
"sortingPosition": 1
},
"children": \[],
"name": "Hawaiian Pizza",
"price": 17000,
"sku": "2135092198",
"sortingPosition": 1,
"type": "PRODUCT",
"combo": true
}
]
}URL url = new URL("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu");HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");
connection.setDoOutput(true);String jsonInputString = "{\n" +
"  "storeId": "900103361",\n" +
"  "items": \[\n" +
"    {\n" +
"      "category": {\n" +
"        "id": "2090019638",\n" +
"        "maxQty": 0,\n" +
"        "minQty": 0,\n" +
"        "name": "Burgers",\n" +
"        "sortingPosition": 0\n" +
"      },\n" +
"      "children": \[\n" +
"        {\n" +
"          "category": {\n" +
"            "id": "211",\n" +
"            "maxQty": 1,\n" +
"            "minQty": 0,\n" +
"            "name": "Do you want to add?",\n" +
"            "sortingPosition": 0\n" +
"          },\n" +
"          "children": \[],\n" +
"          "name": "French Fries",\n" +
"          "price": 5000,\n" +
"          "sku": "2135092145",\n" +
"          "sortingPosition": 1,\n" +
"          "type": "TOPPING",\n" +
"          "maxLimit": 1\n" +
"        },\n" +
"        {\n" +
"          "category": {\n" +
"            "id": "211",\n" +
"            "maxQty": 1,\n" +
"            "minQty": 0,\n" +
"            "name": "Do you want to add?",\n" +
"            "sortingPosition": 0\n" +
"          },\n" +
"          "children": \[],\n" +
"          "name": "Potato Wedges",\n" +
"          "price": 7000,\n" +
"          "sku": "2135092145",\n" +
"          "sortingPosition": 1,\n" +
"          "type": "TOPPING",\n" +
"          "maxLimit": 1\n" +
"        }\n" +
"      ],\n" +
"      "name": "Grilled Chicken Burger",\n" +
"      "price": 14000,\n" +
"      "sku": "2135092145",\n" +
"      "sortingPosition": 0,\n" +
"      "type": "PRODUCT"\n" +
"      "combo": true\n" +
"    },\n" +
"    {\n" +
"      "category": {\n" +
"        "id": "2090019639",\n" +
"        "maxQty": 0,\n" +
"        "minQty": 0,\n" +
"        "name": "Pizzas",\n" +
"        "sortingPosition": 1\n" +
"      },\n" +
"      "children": \[],\n" +
"      "name": "Hawaiian Pizza",\n" +
"      "price": 17000,\n" +
"      "sku": "2135092145",\n" +
"      "sortingPosition": 1,\n" +
"      "type": "PRODUCT"\n" +
"      "combo": true\n" +
"    }\n" +
"  ]\n" +
"}\n";try (OutputStream os = connection.getOutputStream()) {
byte\[] input = jsonInputString.getBytes(StandardCharsets.UTF\_8);
os.write(input, 0, input.length);
}try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "POST",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/menu",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});var postData = JSON.stringify({
storeId: "900103361",
items: \[
{
category: {
id: "2090019638",
maxQty: 0,
minQty: 0,
name: "Burgers",
sortingPosition: 0,
},
children: \[
{
category: {
id: "211",
maxQty: 1,
minQty: 0,
name: "Do you want to add?",
sortingPosition: 0,
},
children: \[],
name: "French Fries",
price: 5000,
sku: "2135092145",
sortingPosition: 1,
type: "TOPPING",
maxLimit: 1,
},
{
category: {
id: "211",
maxQty: 1,
minQty: 0,
name: "Do you want to add?",
sortingPosition: 0,
},
children: \[],
name: "Potato Wedges",
price: 7000,
sku: "2135092145",
sortingPosition: 1,
type: "TOPPING",
maxLimit: 1,
},
],
name: "Grilled Chicken Burger",
price: 14000,
sku: "2135092145",
sortingPosition: 0,
type: "PRODUCT",
combo: true,
},
{
category: {
id: "2090019639",
maxQty: 0,
minQty: 0,
name: "Pizzas",
sortingPosition: 1,
},
children: \[],
name: "Hawaiian Pizza",
price: 17000,
sku: "2135092145",
sortingPosition: 1,
type: "PRODUCT",
combo: true,
},
],
});req.write(postData);req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu"payload = "{\n"&#x20;
"  "storeId": "900103361",\n"&#x20;
"  "items": \[\n"&#x20;
"    {\n"&#x20;
"      "category": {\n"&#x20;
"        "id": "2090019638",\n"&#x20;
"        "maxQty": 0,\n"&#x20;
"        "minQty": 0,\n"&#x20;
"        "name": "Burgers",\n"&#x20;
"        "sortingPosition": 0\n"&#x20;
"      },\n"&#x20;
"      "children": \[\n"&#x20;
"        {\n"&#x20;
"          "category": {\n"&#x20;
"            "id": "211",\n"&#x20;
"            "maxQty": 1,\n"&#x20;
"            "minQty": 0,\n"&#x20;
"            "name": "Do you want to add?",\n"&#x20;
"            "sortingPosition": 0\n"&#x20;
"          },\n"&#x20;
"          "children": \[],\n"&#x20;
"          "name": "French Fries",\n"&#x20;
"          "price": 5000,\n"&#x20;
"          "sku": "2135092145",\n"&#x20;
"          "sortingPosition": 1,\n"&#x20;
"          "type": "TOPPING",\n"&#x20;
"          "maxLimit": 1\n"&#x20;
"        },\n"&#x20;
"        {\n"&#x20;
"          "category": {\n"&#x20;
"            "id": "211",\n"&#x20;
"            "maxQty": 1,\n"&#x20;
"            "minQty": 0,\n"&#x20;
"            "name": "Do you want to add?",\n"&#x20;
"            "sortingPosition": 0\n"&#x20;
"          },\n"&#x20;
"          "children": \[],\n"&#x20;
"          "name": "Potato Wedges",\n"&#x20;
"          "price": 7000,\n"&#x20;
"          "sku": "2135092145",\n"&#x20;
"          "sortingPosition": 1,\n"&#x20;
"          "type": "TOPPING",\n"&#x20;
"          "maxLimit": 1\n"&#x20;
"        }\n"&#x20;
"      ],\n"&#x20;
"      "name": "Grilled Chicken Burger",\n"&#x20;
"      "price": 14000,\n"&#x20;
"      "sku": "2135092145",\n"&#x20;
"      "sortingPosition": 0,\n"&#x20;
"      "type": "PRODUCT"\n"&#x20;
"      "combo": true\n"&#x20;
"    },\n"&#x20;
"    {\n"&#x20;
"      "category": {\n"&#x20;
"        "id": "2090019639",\n"&#x20;
"        "maxQty": 0,\n"&#x20;
"        "minQty": 0,\n"&#x20;
"        "name": "Pizzas",\n"&#x20;
"        "sortingPosition": 1\n"&#x20;
"      },\n"&#x20;
"      "children": \[],\n"&#x20;
"      "name": "Hawaiian Pizza",\n"&#x20;
"      "price": 17000,\n"&#x20;
"      "sku": "2135092145",\n"&#x20;
"      "sortingPosition": 1,\n"&#x20;
"      "type": "PRODUCT"\n"&#x20;
"      "combo": true\n"&#x20;
"    }\n"&#x20;
"  ]\n"&#x20;
"}\n"
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("POST", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"strings"
"net/http"
"io/ioutil"
)func main() {} of your request requires:JSONThis table describes the attributes that the   | The position of the category within the product                                                                                 |required | integeritems.children.category.sortingPosition  | The minimum quantity of elements that can be ordered in this category (In toppings, if it's 0 it means that it's not mandatory) |
| required          | integeritems.children.category.maxQty  | The maximum number of items that can be ordered in this category                                                                |
| required          | integeritems.children.category.minQty  | Category name                                                                                                                   |
| required             | stringitems.children.category.name  | The SKU (Stock-Keeping Unit) the ally gives to this category                                                                    |
| required               | stringitems.children.category.id  | Category of the topping in the menu                                                                                             |
| required                  | stringitems.children.category  | Maximum indicator of the item, it's required only if the type is topping                                                        |
| optional                 | integeritems.children.maxLimit  | The position of the topping in its category                                                                                     |
| optional          | integeritems.children.sortingPosition  | List of the identifiers Rappi gives to this item                                                                                |
| optional         | array of stringitems.children.rappiIds  | Image url of the topping in the menu                                                                                            |
| optional                  | stringitems.children.imageUrl  | Price of the topping in the menu                                                                                                |
| required                    | integeritems.children.price                                                                                   |
| TOPPING  | Item type. In this case can be only required                      | stringitems.children.type  | SKU that the ally assigned for the topping in the menu                                                                          |
| required                       | stringitems.children.sku  | Description of the topping in the menu                                                                                          |
| required               | stringitems.children.description  | Name of the topping in the menu                                                                                                 |
| required                      | stringitems.children.name  | List of product's toppings from the menu                                                                                        |
| optional                 | array of objectsitems.children  | it's the position of the category in the menu                                                                                   |
| required          | integeritems.category.sortingPosition  | The minimum quantity of elements that can be ordered in this category (In toppings, if it's 0 it means that it's not mandatory) |
| required                   | integeritems.category.maxQty  | The maximum number of items that can be ordered in this category                                                                |
| required                   | integeritems.category.minQty  | Category name                                                                                                                   |
| required                      | stringitems.category.name  | The SKU (Stock-Keeping Unit) the ally gives to this category                                                                    |
| required                        | stringitems.category.id  | Category of the product in the menu                                                                                             |
| required                           | stringitems.category  | Indicates if the element belongs to a combo                                                                                     |
| optional                             | booleanitems.combo  | Maximum indicator of the item, it's required only if the type is topping                                                        |
| optional                          | integeritems.maxLimit  | The position of the product in its category                                                                                     |
| optional                   | integeritems.sortingPosition  | List of the identifiers Rappi gives to this item                                                                                |
| optional                  | array of stringitems.rappiIds  | Image url of the product in the menu                                                                                            |
| optional                           | stringitems.imageUrl  | Price of the product in the menu                                                                                                |
| required                             | integeritems.price                                                                                   |
| PRODUCT  | Item type. In this case can be only required                               | stringitems.type  | SKU that the ally assigned for the product in the menu                                                                          |
| required                                | stringitems.sku  | Description of the product in the menu                                                                                          |
| required                        | stringitems.description  | Name of the product in the menu                                                                                                 |
| required                               | stringitems.name  | Product list                                                                                                                    |
| required                          | array of objectsitems  | Identifier of the store in the Rappi application.                                                                               |
| required                                  | stringstoreId| Attributes                                              | Requirement | Description                                                                                                                     |
| ------------------------------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------- |
|


These are the possible status codes of the response for this endpoint: Menu updated and ready to be validated200


This resource has the following properties: |
| Authentication requirements | Token  |JSON |
| Request body requirements   | JSON|                             |        |
| --------------------------- | ------ |
| Response formats            |


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/menuSee the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


Use this endpoint to create a new menu, or to add new items to an existing one, for the authenticated ally. endpoint.GET menu/approved/{storeId}After creating a menu, or adding new items to an existing one, the Rappi team validates the items and the structure of the menu. You can consult the status of the approval process by using the


{
"message": "Not a valid token"
}This table describes the attributes from JSON response: | Not a valid token |stringmessage| Attributes             | Description       |
| ---------------------- | ----------------- |
|


Sample Response "Invalid credentials 401":

This is an example of the response:\[
{
"storeId": "900111978",
"items": \[
{
"name": "Naked Cake con frutos",
"description": "Naked cake decorado con frutos. Cubierta de trufa derretida (ganache) y decorada con frutos del bosque.",
"sku": "8569874",
"type": "PRODUCT",
"price": 75.0,
"category": {
"id": "3",
"name": "Tortas",
"minQty": 0,
"maxQty": 0,
"sortingPosition": 0
},
"imageUrl": "https://image.com/image1.jpg",
"children": \[
{
"name": "Chocolate",
"description": "",
"sku": "8569874-159",
"type": "TOPPING",
"price": 0.0,
"category": {
"id": "1",
"name": "Sabor",
"minQty": 0,
"maxQty": 1,
"sortingPosition": 0
},
"imageUrl": "https://image.com/image10.jpg",
"children": \[],
"rappiIds": \["340948822"],
"sortingPosition": 1,
"maxLimit": 1
}
],
"rappiIds": \["2135527868"],
"sortingPosition": 0,
"maxLimit": 1
},
{
"name": "Snowman",
"description": "Linda lata de Snowman con productos variadosIncluye:Galletas mantequilla 350 gr, 6 brookies y 4 trufas de brownie.",
"sku": "856887",
"type": "PRODUCT",
"price": 75.0,
"category": {
"id": "9",
"name": "Navidad",
"minQty": 0,
"maxQty": 0,
"sortingPosition": 0
},
"imageUrl": "https://image.com/image2.jpg",
"children": \[],
"rappiIds": \["2135524472"],
"sortingPosition": 0,
"maxLimit": 1
}
]
}
]This table describes the objects contained in the response example: | The position of the category within the product                                                                                 |integeritems.children.category.sortingPosition          | The minimum quantity of elements that can be ordered in this category (In toppings, if it's 0 it means that it's not mandatory) |
| integeritems.children.category.maxQty          | The maximum number of items that can be ordered in this category                                                                |
| integeritems.children.category.minQty             | Category name                                                                                                                   |
| stringitems.children.category.name               | The SKU (Stock-Keeping Unit) the ally gives to this category                                                                    |
| stringitems.children.category.id                  | Category of the topping in the menu                                                                                             |
| stringitems.children.category                 | Maximum indicator of the item, it's required only if the type is topping                                                        |
| integeritems.children.maxLimit          | The position of the topping in its category                                                                                     |
| integeritems.children.sortingPosition         | List of the identifiers Rappi gives to this item                                                                                |
| array of stringitems.children.rappiIds                  | Image url of the topping in the menu                                                                                            |
| stringitems.children.imageUrl                    | Price of the topping in the menu                                                                                                |
| integeritems.children.price                                                                                   |
| TOPPING                      | Item type. In this case can be only stringitems.children.type                       | SKU that the ally assigned for the topping in the menu                                                                          |
| stringitems.children.sku               | Description of the topping in the menu                                                                                          |
| stringitems.children.description                      | Name of the topping in the menu                                                                                                 |
| stringitems.children.name                 | List of product's toppings from the menu                                                                                        |
| array of objectsitems.children          | it's the position of the category in the menu                                                                                   |
| integeritems.category.sortingPosition                   | The minimum quantity of elements that can be ordered in this category (In toppings, if it's 0 it means that it's not mandatory) |
| integeritems.category.maxQty                   | The maximum number of items that can be ordered in this category                                                                |
| integeritems.category.minQty                      | Category name                                                                                                                   |
| stringitems.category.name                        | The SKU (Stock-Keeping Unit) the ally gives to this category                                                                    |
| stringitems.category.id                           | Category of the product in the menu                                                                                             |
| stringitems.category                          | Maximum indicator of the item, it's required only if the type is topping                                                        |
| integeritems.maxLimit                   | The position of the product in its category                                                                                     |
| integeritems.sortingPosition                  | List of the identifiers Rappi gives to this item                                                                                |
| array of stringitems.rappiIds                           | Image url of the product in the menu                                                                                            |
| stringitems.imageUrl                             | Price of the product in the menu                                                                                                |
| integeritems.price                                                                                   |
| PRODUCT                               | Item type. In this case can be only stringitems.type                                | SKU that the ally assigned for the product in the menu                                                                          |
| stringitems.sku                        | Description of the product in the menu                                                                                          |
| stringitems.description                               | Name of the product in the menu                                                                                                 |
| stringitems.name                          | Product list                                                                                                                    |
| array of objectsitems                                  | Identifier of the store in the Rappi application.                                                                               |
| stringstoreId| Response Object                                         | Object Description                                                                                                              |
| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
|


Sample Response "Success 200":

This is an example of an API request using this endpoint:GET https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menuThis is an example of the request:URL url = new URL("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu");HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/menu"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("GET", url, headers=headers, data=payload)print(response.text.encode('utf8'))var https = require("https");var options = {
method: "GET",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/menu",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


Use this endpoint to return the collection of menus created by the authenticating ally.


The Menus resource enables you to interact with the menus of your stores.The following table describes the different contents of the Menus resource:       | Returns the last menu created for a store                          |GET menu/rappi/{storeId} | Returns the current approval status of a menu                      |
| GET menu/approved/{storeId}                                    | Creates or updates a menu in a store                               |
| POST menu                                      | Returns the collection of menus created by the authenticating ally |
| GET menu| Resource                                                     | Description                                                        |
| ------------------------------------------------------------ | ------------------------------------------------------------------ |
|


This is an example of the response:\[
{
"event": "canceled\_with\_charge",
"event\_time": "2020-05-28T12:31:12.501Z",
"additional\_information": {}
},
{
"event": "taken\_visible\_order",
"event\_time": "2020-05-28T12:30:12.501Z",
"additional\_information": {
"eta\_to\_store": "15"
}
}
]This table describes the objects contained in the response example: | Courier estimated time of arrival to the store.                                   |stringadditional\_information.eta\_to\_store    | Additional information for the order. The format can vary depending on the event. |
| array of objectsadditional\_information'Z'.                      |
| HH:mm:ss.SSS'T'yyyy-MM-dd                          | Time of the event. Format: stringevent\_time                               | Latest order event.                                                               |
| stringevent| Response Object                                    | Object Description                                                                |
| -------------------------------------------------- | --------------------------------------------------------------------------------- |
|


These are the possible status codes of the response for this endpoint: Success200 Invalid credentials401 Order not found404


This is an example of an API request using this endpoint:GET https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/eventsThis is an example of the request:final Integer orderId = 392625;URL url = new URL(String.format("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/%s/events", orderId));HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "GET",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/orders/392625/events",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/events"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("GET", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/orders/{orderId}/events: This is the identifier of your order.{orderId}See the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


Use this endpoint to retrieve the latest status updates from your orders.


This endpoint returns a status response code only.


This is an example of an API request using this endpoint:POST https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/ready-for-pickupThis is an example of the request:final Integer orderId = 392625;URL url = new URL(String.format("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/%s/ready-for-pickup", orderId));HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "POST",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/orders/392625/ready-for-pickup",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/ready-for-pickup"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("POST", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


These are the possible status codes of the response for this endpoint: Order successfully updated200 Invalid state transition400 Invalid credentials401 Order not found404


This endpoint does not permit additional parameters.!!! important
To prevent misuse of the endpoint, we reserve the right to revoke access to clients who use it improperly. Therefore, after three requests, the system will stop executing additional actions, and any further attempts will be considered improper use of the endpoint.


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/orders/{orderId}/ready-for-pickup: This is the identifier of your order.{orderId}See the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


Use this endpoint to notify the courier in the Rappi application that the order is ready for pickup.
When the first request is made, if no courier is assigned, the system will speed up the assignment process; if a courier is already assigned, a notification will be sent to them, and the order status will change to READY\_FOR\_PICKUP. On the second request, if a courier is already assigned, a new notification will be sent to the assigned courier.


This is an example of an API request using this endpoint:PUT https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/rejectThis is an example of the request:{
"reason": "The order has invalid items"
}This is an example of the request with offending items:{
"reason": "The order has invalid items",
"cancel\_type": "ITEM\_NOT\_FOUND",
"items\_skus": \["sku1", "sku2"]
}final Integer orderId = 3320025;URL url = new URL(String.format("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/%s/reject", orderId));HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("PUT");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");
connection.setDoOutput(true);String jsonInputString = "{"reason":"The order has invalid items"}";try (OutputStream os = connection.getOutputStream()) {
byte\[] input = jsonInputString.getBytes(StandardCharsets.UTF\_8);
os.write(input, 0, input.length);
}System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "PUT",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/orders/392625/reject",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
maxRedirects: 20,
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});var postData = JSON.stringify({ reason: "The order has invalid items" });req.write(postData);req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/reject"payload = "{"reason":"The order has invalid items"}"
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("PUT", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"strings"
"net/http"
"io/ioutil"
)func main() {} of your request requires:JSONThis table describes the attributes that the   | Reason to reject the order |required | stringreason| Attributes            | Requirement | Description                |
| --------------------- | ----------- | -------------------------- |
|


These are the possible status codes of the response for this endpoint: Order successfully rejected200 Invalid state transition400 Invalid credentials401 Order not found404


|"ORDER\_TOTAL\_INCORRECT", "ORDER\_MISSING\_ADDRESS\_INFORMATION", "ORDER\_MISSING\_INFORMATION", "ITEM\_OUT\_OF\_STOCK", "ITEM\_NOT\_FOUND", "ITEM\_WRONG\_PRICE"  | Enum: required | enumerable stringcancel\_type  | List of offending items skus. Here you should use your skus                                                                                                            |
| optional           | array of stringitems\_skus  | List of offending items ids. Here you should use the rappi ids                                                                                                         |
| optional            | array of stringitems\_ids  | Rejects a specific order.                                                                                                                                              |
| required                       | stringorderId| Name                                         | Requirement | Description                                                                                                                                                            |
| -------------------------------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/orders/{orderId}/reject: This is the identifier of the order.{orderId}See the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


This is an example of an API request using this endpoint:PUT https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/take/20this is an example of the request:final Integer orderId = 392625;
final Integer cookingTime = 20;URL url = new URL(String.format("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/%s/take/%s", orderId, cookingTime));HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("PUT");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");
connection.setDoOutput(true);System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "PUT",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/orders/392625/take/20",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/392625/take/20"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("PUT", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


These are the possible status codes of the response for this endpoint: Order successfully taken200 Invalid state transition400 Invalid credentials401 Order not found404


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/orders/{orderId}/take/{cookingTime}: This is the new cooking time of the order. You can leave this field empty to keep the default cooking time of the order.{cookingTime}: This is the identifier of the order.{orderId}See the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


Use this endpoint to take an order, so the store commences preparing it.


This is an example of an API request using this endpoint:GET https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/status/sentthis is an example of the request:URL url = new URL("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/status/sent");HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "GET",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/orders/status/sent",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders/status/sent"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("GET", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


These are the possible status codes of the response for this endpoint: Success200 The store don't belong to the appClient of given id400 Invalid credentials401 Store not found404


This endpoint admits the following optional additional parameters: | Returns only the orders from a specific store |{storeId}| Parameter   | Description                                   |
| ----------- | --------------------------------------------- |
|


Use this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/orders/status/sentSee the list of Country Domains.: This is your Rappi Country Domain. {COUNTRY\_DOMAIN}


for the stores of the authenticating ally.SENTUse this endpoint to return a collection of all the new orders status


This is an example of an API request using this endpoint:GET https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/ordersthis is an example of the request:URL url = new URL("https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders");HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("User-Agent", "Mozilla/5.0");
connection.setRequestProperty("Content-Type", "application/json");
connection.setRequestProperty("Accept", "application/json");
connection.setRequestProperty("x-authorization", "Bearer YOUR\_TOKEN");try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF\_8))) {
StringBuilder response = new StringBuilder();
String responseLine;
while ((responseLine = br.readLine()) != null) {
response.append(responseLine.trim());
}
System.out.println("Response body: " + response.toString());
}
System.out.println("Response Code : " + connection.getResponseCode());var https = require("https");var options = {
method: "GET",
hostname: "microservices.dev.rappi.com",
path: "/api/v2/restaurants-integrations-public-api/orders",
headers: {
"Content-Type": "application/json",
"x-authorization": "Bearer YOUR\_TOKEN",
},
};var req = https.request(options, function (res) {
var chunks = \[];res.on("data", function (chunk) {
chunks.push(chunk);
});res.on("end", function (chunk) {
var body = Buffer.concat(chunks);
console.log(body.toString());
});res.on("error", function (error) {
console.error(error);
});
});req.end();import requestsurl = "https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/orders"payload = {}
headers = {
'Content-Type': 'application/json',
'x-authorization': 'Bearer YOUR\_TOKEN'
}response = requests.request("GET", url, headers=headers, data=payload)print(response.text.encode('utf8'))package mainimport (
"fmt"
"net/http"
"io/ioutil"
)func main() {}


Availability

The Availability resources allow you to interact with the availability options of your items and stores.

The following table describes the different contents of the Availability resources:


The Availability resources allow you to interact with the availability options of your items and stores.The following table describes the different contents of the Availability resources:


AvailabilityThe Availability resources allow you to interact with the availability options of your items and stores.!!! important
Due to expansion and improvements, new endpoints or resources have been introduced that expand the capabilities for interacting with various item and store availability options. Because of these advancements, this section is now divided into two distinct parts, each with its own List of Country Domains. It's essential to note that the current availability section remains fully operational and contains the traditional resources that have previously handled the established availability options.The following table describes the different contents of the Availability resources related to this List of Country Domains.| Resource                                                                            | Description                                                      |
| ----------------------------------------------------------------------------------- | ---------------------------------------------------------------- |
| POST availability/items/status                 | Returns the availability of items by Item SKU.                   |
| POST availability/items/rappi/status     | Returns the availability of items by Item ID.                    |
| PUT availability/stores/items                   | Manage item availability in the application by Item SKU          |
| PUT availability/stores/items/rappi       | Manage item availability in the application by Item ID           |
| POST availability/stores                             | Returns the availability status of the stores in the application |
| PUT availability/stores                               | Manage store availability asynchronously in the application      |
| PUT availability/stores/enable/massive | Manage store availability asynchronously in the application      |
| PUT availability/stores/enable                 | Manage store availability synchronously in the application       |POST availability/items/statusUse this endpoint to check the availability options of your items by SKU in your stores.Endpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores/items{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response for this endpoint:200 SuccessSample RequestThis is an example of an API request using this endpoint:POST https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/items/statusThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes                       | Requirement | Description                                  |
| -------------------------------- | ----------- | -------------------------------------------- |
| store\_idstring           | required  | Identifier of the store.                     |
| item\_idsarray of strings | required  | List of the SKUs of the articles to consult. |Sample ResponseThis is an example of the response:This table describes the objects within the sample response::| Object in response            | Description                     |
| ----------------------------- | ------------------------------- |
| item\_idinteger        | Identifier of the item.         |
| item\_typestring       | Type of product in the menu.    |
| stock\_out\_statestring | Indicates product availability. |These are the possible responses for the request:If the request succeeds, the endpoint returns a Success response code.If the request fails, the endpoint returns an Error response code with an error message in a JSON.POST availability/items/rappi/statusUse this endpoint to check the availability options of your items by ID in your stores.Endpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores/items{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response for this endpoint:200 SuccessSample RequestThis is an example of an API request using this endpoint:POST https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/items/rappi/statusThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes                       | Requirement | Description                                 |
| -------------------------------- | ----------- | ------------------------------------------- |
| store\_idstring           | required  | Identifier of the store.                    |
| item\_idsarray of strings | required  | List of the IDs of the articles to consult. |Sample ResponseThis is an example of the response:This table describes the objects within the sample response::| Object in response            | Description                     |
| ----------------------------- | ------------------------------- |
| item\_idinteger        | Identifier of the item.         |
| item\_typestring       | Type of product in the menu.    |
| stock\_out\_statestring | Indicates product availability. |These are the possible responses for the request:If the request succeeds, the endpoint returns a Success response code.If the request fails, the endpoint returns an Error response code with an error message in a JSON.PUT availability/stores/itemsUse this endpoint to configure the availability options of your items by SKU in your stores.Endpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores/items{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response for this endpoint:200 Success401 Error updating items404 Invalid CredentialsSample RequestThis is an example of an API request using this endpoint:PUT https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/stores/itemsThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes                          | Requirement | Description                            |
| ----------------------------------- | ----------- | -------------------------------------- |
| store\_integration\_idstring | required  | Identifier of the store integration.   |
| itemsarray of objects      | required  | Properties of the items you configure. |
| items.turn\_onstring        | optional  | SKU of the item to turn on.            |
| items.turn\_offstring       | optional  | SKU of the item to turn off.           |Sample ResponseThis is an example of the response with an error message:These are the possible responses for the request:If the request succeeds, the endpoint returns a Success response code.If the request fails, the endpoint returns an Error response code with an error message in a JSON.PUT availability/stores/items/rappiUse this endpoint to configure the availability options of your items by Rappi ID in your stores.Endpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores/items/rappi{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response for this endpoint:200 Items successfully updated401 Error updating items404 Invalid credentialsSample RequestThis is an example of an API request using this endpoint:PUT https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/stores/items/rappiThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes                          | Requirement | Description                            |
| ----------------------------------- | ----------- | -------------------------------------- |
| store\_integration\_idstring | required  | Identifier of the store integration.   |
| itemsarray of objects      | required  | Properties of the items you configure. |
| items.turn\_oninteger       | optional  | Rappi ID of the item to turn on.       |
| items.turn\_offinteger      | optional  | Rappi ID the item to turn off.         |Sample ResponseThis is an example of the response with an error message:These are the possible responses for the request:If the request succeeds, the endpoint returns a Success response code.If the request fails, the endpoint returns an Error response code with an error message in a JSON.POST availability/storesUse this endpoint to check the availability of your stores.Endpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response for this endpoint:200 Stores consulted successfully400 You are consulting a number of stores greater than the maximum allowed (100 stores)401 Invalid credentials429 Too many requests are being sent in a given period of timeSample RequestThis is an example of an API request using this endpoint:POST https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/storesThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes               | Requirement | Description                                       |
| ------------------------ | ----------- | ------------------------------------------------- |
| Store listinteger | required  | List of store IDs to consult separated by commas. |Sample ResponseThis is an example of a Success response:This is an example of the response with an error message:These are the possible responses to the request:If the request is successful, the endpoint returns a Success code with an object in JSON format.If the request fails, the endpoint returns an Error response code with an error message in a JSON.PUT availability/storesUse this endpoint to configure the availability options of your stores.Endpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response for this endpoint:200 Stores successfully updated401 Error updating stores404 Invalid credentialsSample RequestThis is an example of an API request using this endpoint:PUT https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/storesThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes               | Requirement | Description                    |
| ------------------------ | ----------- | ------------------------------ |
| turn\_oninteger  | optional  | List of store IDs to turn on.  |
| turn\_offinteger | optional  | List of store IDs to turn off. |Sample ResponseThis is an example of the response with an error message:These are the possible responses to the request:If the request succeeds, the endpoint returns a Success response code.If the request fails, the endpoint returns an Error response code with an error message in a JSON.PUT availability/stores/enable/massiveUse this endpoint to configure the availability options of your stores.Endpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response for this endpoint:200 Stores successfully updated400 Error updating stores401 Invalid credentialsSample RequestThis is an example of an API request using this endpoint:PUT https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/stores/enable/massiveThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes                        | Requirement | Description                                              |
| --------------------------------- | ----------- | -------------------------------------------------------- |
| storesarray of objects   | required  | List of store's data                                     |
| stores.store\_idstring    | required  | id of the store (rappi side) that will change the status |
| stores.is\_enabledboolean | required  | true to turn on the store, otherwise false           |Sample ResponseThis is an example of the response with an error message:These are the possible responses to the request:If the request succeeds, the endpoint returns a Success response code.If the request fails, the endpoint returns an Error response code with an error message in a JSON.PUT availability/stores/enableUse this endpoint to configure the availability options of your stores synchronouslyEndpoint URLUse this URL to make a request with this endpoint:https://{COUNTRY\_DOMAIN}/api/v2/restaurants-integrations-public-api/availability/stores/enable{COUNTRY\_DOMAIN}: This is your Rappi Country Domain. See the list of Country Domains.Endpoint PropertiesThis resource has the following properties:|                             |        |
| --------------------------- | ------ |
| Response formats            | JSON |
| Request body requirements   | JSON |
| Authentication requirements | Token  |ParametersThis endpoint does not permit additional parameters.Status CodesThese are the possible status codes of the response to this endpoint:200 Stores updated successfully400 Bad Request403 You are not allowed to update those stores422 Amount of stores exceeded502 Internal error trying to update the storesSample RequestThis is an example of an API request using this endpoint:PUT https://microservices.dev.rappi.com/api/v2/restaurants-integrations-public-api/availability/stores/enableThis is an example of the request:This table describes the attributes that the JSON of your request requires:| Attributes                        | Requirement | Description                                             |
| --------------------------------- | ----------- | ------------------------------------------------------- |
| storesarray of objects   | required  | List of store's data                                    |
| stores.store\_idstring    | required  | id of the store (your side) that will change the status |
| stores.is\_enabledboolean | required  | true to turn on the store, otherwise false          |Sample ResponseThis is an example of a successful response:This is an example of an error response:This table describes the attributes that the JSON of the response contains:| Response Object                                 | Object Description                                                                                                     |
| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| resultsarray of objects                | Result list                                                                                                            |
| results.store\_idint                    | Store id.                                                                                                              |
| results.is\_enabledboolean              | Current store status                                                                                                   |
| results.operation\_resultboolean        | true if the operation has been finished successfully, otherwise false.                                             |
| results.operation\_result\_typestring    | Possible values: SUCCESS, SUSPENDED, FORBIDDEN, STORE\_NOT\_PUBLISHED, STORE\_ALREADY\_IN\_STATUS, ERROR\_EXTERNAL\_SERVICE |
| results.operation\_result\_messagestring | Result type description                                                                                                |
| results.suspended\_reasonstring         | If the store has been suspended, the reason will be here                                                               |
| results.suspended\_atdate               | Date since the store has been suspended                                                                                |
| results.suspended\_timeint              | Time in minutes that indicates for how long the store will be suspended                                                |Meaning of the different operation\_result\_type valuesSTORE\_NOT\_PUBLISHED: the store is not currently showing on the appSUSPENDED: the store has been suspended and it is not possible to turn it onERROR\_EXTERNAL\_SERVICE: there was an error trying to change the store statusSTORE\_ALREADY\_IN\_STATUS: the store is already in the status you are trying to change toFORBIDDEN: the authenticated client\_id is not allowed to change the status for the specified storeSUCCESS: the store was updated successfully


The Availability resources allow you to interact with the availability options of your items and stores.!!! important
Due to expansion and improvements, new endpoints or resources have been introduced that expand the capabilities for interacting with various item and store availability options. Because of these advancements, this section is now divided into two distinct parts, each with its own List of Country Domains. It's essential to note that the current availability section remains fully operational and contains the traditional resources that have previously handled the established availability options.
