Skip to content
Download OpenAPI description
Overview
Keeta Developer Website

https://developers.mykeeta.com/

Languages
Servers

https://open.mykeeta.com/api/open/opendelivery/

General Info

Special Note:

  • Keeta Open Delivery API is based on Open Delivery v1.5.0. For basic understanding, please refer to Open Delivery API.

  • For some of the APIs, Keeta has made some adjustments based on business scenarios. Therefore, when Software Service integrates with Keeta, please refer to the APIs definitions in this document.
    The major changes include:

    • Authentication: The credentials have been changed from the merchant level to the software level, and the token as well. However, software services cannot access the merchant data without the merchant's authorization first.
    • Signature: Keeta requires the Software Service to include a signature in the header of every API request. This is to enhance security and prevent the risk of data leakage due to token exposure (such as man-in-the-middle attacks).Please refer to the detailed documentation for the specific signing requirements.
    • Merchant Menu: Keeta supports menu push (software services push via POST /merchantUpdate interface) and pull (Keeta pulls via GET /merchant interface); however, Keeta currently only supports full menu updates (modular entry updates are not supported at this time). For details, please refer to the description of the corresponding Merchant endpoints in this document.
    • Order: Keeta supports querying order events of batch merchants in the polling endpoint, since the credential is in the software level.
    • Fields: Keeta has made some adjustments to the fields in each endpoint, including the number of fields, whether the fields are required, etc. Please refer to the definitions in this document.
    • Refund Process: When requesting a total/partial refund after order completion, a negotiation will be initiated between the Customer and the Merchant. This allows the Merchant the opportunity to ACCEPT or DENY the Customer's request. For details, refer to ORDERS section.
    • User Privacy Data: To protect users' personal privacy, Keeta will return encrypted data in order details. In scenarios involving merchant self-delivery or third-party logistics (3PL), this data can be decrypted. If Software Services need to decrypt the data, they must make additional calls to the data decryption endpoint. For details, please refer to the description in the Order section of this document.
  • We strongly recommend software services to integrate the menu API for data synchronization, to avoid merchants maintaining menus in multiple places.

  • Keeta provides a self-service authorization feature in its merchant management system . Merchants can log in to the system to independently authorize or revoke access for Software Services. Detailed instructions are available in the relevant documentation section .

  • In addition, Keeta offers API endpoints that enable Software Services to automate merchant authorization and embed the workflow into their own SaaS software. For implementation details, please refer to the relevant documentation section .

  • You can Download the Postman Collection and add signature calculation script to the pre-request section in Postman to simplify integration and testing.

    Important :You need to replace the secret value in the Postman script with the one assigned to you by Keeta.

  • For some general instructions, can directly refer to Open Delivery Documents, and relevant links will be attached.

How to Start

Preparation Phase

  1. NDA

  2. Please contact the Keeta team to sign the NDA (Non-disclosure Agreement).

  3. Complete profile information

  4. After you have signed the NDA, Keeta API experts will share developer account and test application ID and secret with you. Log in to the Keeta Developer Portal using the developer account we provided. Please complete the profile on the Information Management page of the Dev Portal, including company logo, contact phone number, contact email, and merchant operations email. These details are essential—make sure all information is fully filled out and accurate.

    Please note that your company logo will be visible to customers, so ensure it is uploaded correctly. Additionally, Keeta will send the test store credentials and merchant onboarding details to the email addresses listed above — please double-check that they are accurate.

  5. Set up test store and Keeta test APP

    1. a. Please log in to the Dev Portal and use the Test Store Tool to create a test store.
    2. b. During the store creation process, please scan the Keeta App QR code to download the Keeta Test App. Then, register as a Keeta user using your mobile phone number.
    3. c. Once registration is complete, enter your phone number to link your user account with the test store. After this step, you’ll be able to view your test store within the app.
    4. d. For instructions on using test store in Keeta test APP, click here .
    5. e. Once you've created a test store, the credentials will be sent to the primary contact email. You can then use the account to log into the Keeta Merchant Management System , where you'll be able to manage store business hours, basic information, and menus.

Development Phase

  1. SOW (Statement of Work)

  2. Before initiating technical development, please download the SOW file from the Integration Document Management section. Complete the document before the online integration testing (SIT homologation) with Keeta, and upload it to the Dev Portal.

    (This file defines the scope of this integration (SOW – Statement of Work) and will help you understand keeta API system).

  3. Developer Self-Test

  4. Please download and review the SIT file, which is a set of self-testing use cases for your reference during internal QA. Keeta team will use the same test cases in the Joint SIT (system integration test) test in the future. We recommend that you follow these test cases to ensure the system functions properly. Please fill in and submit the self-test records before conducting SIT tests with Keeta.

  5. Joint SIT (System Integration Test) with Keeta

  6. After completing the developer self-test, please schedule an online joint SIT test (homologation) with Keeta. Keeta team will attend to conduct test with you and help resolve issues. If the SIT test meets the requirements, Keeta will sign off the test, and assign an application for the production environment (including the ID and secret) to you. It is strongly recommended to conduct thorough self-testing before the joint SIT test with Keeta.

UAT (User Acceptance Test) Phase

  1. Schedule UAT Test

  2. After passing the SIT test, we will coordinate with a common customer (restaurant) and schedule the UAT test (you can also recommend one to us).

  3. Conduct UAT Test (Pilot store test)

  4. Before the test, notify the responsible person of the customer's restaurant to ensure support for the test. The Keeta team will place and pay for orders in the actual store to verify that the software system functions properly (such as menu management, order management, KDS, receipt printing).

    Please note that during the UAT testing phase, you must use the production environment application (which Keeta will assign to you after passing SIT testing) to access Keeta.

    Test applications used during the development phase will not have access to merchant data.

Recommendation

  1. Operational Meeting

  2. We recommend that both parties' operational teams hold an operation meeting after the system integration is completed to discuss the subsequent merchant activation/authorization process and align on daily operation and technical issue handling mechanisms.

    In addition, based on your developer account, Keeta can provide operation accounts upon request. This accounts allow you to view and manage merchants that have authorized your applications on the Dev Portal.

Integrating with Keeta API

  • Authenticate

    All API endpoints (except Get Access Token itself) require authentication. Therefore, you must first obtain an access token by calling the Get Access Token endpoint before making any further requests.

  • Configure Store Mapping and Webhooks

    After obtaining the access token, you can register the mapping between your internal merchantId and the Keeta merchantId, and configure webhook endpoints by calling the Merchant Onboarding endpoint.

  • Place a Test Order

    Once the store mapping has been successfully configured, refer to the Keeta Test App to place a test order for the configured store and proceed to the Order Module testing phase.

  • Order Workflow Testing

    At this stage, whenever a new order is placed from the registered store, you will receive a PLACED event via webhook or polling.

    Upon receiving a PLACED event, you should first retrieve order details, and then either confirm or cancel the order.

    Once the order is prepared, you must either mark it as ready or dispatch it — depending on whether the delivery will be fulfilled by the merchant or a third-party logistics provider.

    ✅ Good job! Your app is now ready to receive and process orders. For more advanced features, please refer to the relevant sections of this documentation.

Basic Concepts

  • PARAMETERS IN THE SOFTWARE SERVICE (SOFTWARE SERVICE --> Keeta)

    • {baseURL}

      • The {baseURL} is the parameter that indicates the base address, i.e. the constant part of the address, where the routes will be called.
    • clientId and clientSecret

      • Keeta is responsible for providing the credentials for authentication to be performed through the authentication endpoint.

        IMPORTANT: As described in the authentication section of the documentation, credentials are generated by Keeta, that is, if several MERCHANTS use the same Software Service, the software will have a same clientId and clientSecret.

    • AppId

      • It is the unique ID of Keeta which is generated by Keeta itself, it will be informed to all the Software Services that it will integrate.
    • X-App-Signature

      • Keeta requires Software Service to generate a signature and include it in the header of each API request. Refer to the Signature Calculation section for the complete algorithm specification.
  • PARAMETERS IN Keeta (Keeta --> SOFTWARE SERVICE)

    • GET /merchant endpoint URL:

      • Keeta must be provided with the URL to access the GET /merchant route to obtain the merchant's information.

      IMPORTANT: Each merchant that the Software Service works with must have a unique URL.

    • apiKey

      • If the GET /merchant endpoint is implemented using authentication, it is necessary that the Software Service provides the apiKey referring to the entered merchant.
    • Order Event Webhook

      • If both parties are going to work with sending order events via webhook, it is necessary to provide the URL of the webhook. Default webhook route: POST {baseURL}/newEvent
  • General Guidelines

    For general guidelines on the Keeta Open Delivery API, please refer directly to Open Delivery General Guidelines.

  • Error Handling

    For error handling guidelines on the Keeta Open Delivery API, please refer directly to Open Delivery Error Handling.

Keeta Developer Portal

Dev Portal is the developer backend for the Keeta API open platform, comprising two main modules:

1. Application Management

In this module, you can create and manage applications, view application tokens, and check the list of associated merchants. For setting regular webhooks, please use the Open Delivery approach to register and update webhooks(e.g., via the " Register / Update Merchant endpoint info " method). For Merchant authorization updates webhooks, you can directly configure them in the webhook setting page. Please focus only on the webhook configuration for Formal Store. 1301 represents the webhook for new authorization notifications, and 1302 represents the webhook for authorization cancellation notifications.

2. Development Testing Tools

  1. Store Mapping Check
    This tool allows you to view and search all authorized merchant lists and their menu push statuses. To validate the accuracy of store mapping between systems, you can upload the store IDs and coordinates recorded in your system to Keeta. The system will automatically calculate the geographical deviation distance to achieve validation.
  2. Test Store Tool
    This tool allows you to create test stores. Please note that you must create an application before proceeding. You can also use this tool to manage the store’s operating status—for example, to reopen a store that was closed due to order failures. After creating a test store, go to Store Details → Edit → Link with your Keeta user account. Be sure to enter the same phone number you used to register as a Keeta user. This will make the test store visible in your app.
  3. Keeta Rider Simulator
    To test the full lifecycle of orders, you can use this tool to simulate the entire fulfillment process of a Keeta rider, including rider dispatching, arrival at the restaurant, food pickup, and delivery completion.
  4. Test Order Tool
    The Test Order Tool is a convenient web-based utility that allows developers to place test orders at designated test stores, enabling quick validation of the order flow. Alternatively, you may choose to download and use the Keeta Test App to browse store menus and place test orders directly.

Test Store Management

You can create a test store yourself in the Dev Portal (see Keeta Developer Portal for details), or use the test store assigned to you by Keeta. Using the account and password of the test store to log into the Keeta Merchant Management System , you will have access to all store management functions, including: viewing orders, viewing historical data, setting store operating hours and status, viewing and editing menus, and setting up promotion activities etc.

Menu Management

If you do not integrate with Keeta's Menu API (i.e., do not manage and publish menus via the API), you can edit and upload menus in the Merchant Management System for testing purposes. If needed, Please use the menu upload template (including PDV Code) to help quickly batch upload full menu and the corresponding external codes. Please contact Keeta team for details and support if needed.

Please note:

If the menu is not integrated, manual entry is required — and it's important to ensure the PDV Code is entered correctly.

However, if menu synchronization is performed via API, Keeta will automatically disable manual entry and modification through the Merchant Management System to prevent data inconsistencies and potential order failures.

If a merchant needs to make manual adjustments to the menu despite API integration, please contact the Keeta API team for support.

Promotion Settings

We recommend setting up various types of marketing activities and placing test orders in the test store to ensure that promotional information in the orders is processed correctly.

Additionally, if you wish to test scenarios involving Keeta platform subsidies, please contact the Keeta API team. We will add Keeta platform promotional items to your test store for this purpose.

Please note that in the SIT testing environment (homologation), we will test scenarios involving both merchant subsidies and platform subsidies to ensure the orders are processed correctly and the promotional information is accurately parsed.

Keeta test APP

To place orders for test stores, there are two available methods:

Developer Portal with Test Order Tool:

Log into the Dev Portal and use the Test Order Tool to directly place orders at the test store. This method is convenient and allows for rapid validation of order flow, but its functionality is limited.

Keeta Test App:

Download and use the Keeta Test App to browse the store menu and place orders directly within the app. This approach enables a full end-to-end simulation from the user perspective, provides a visualized menu interface, and allows you to trigger refund operations—making it essential for testing reverse order flows and other features.

Keeta team will share the download link for the Test APP (available for both Android and iOS versions). Please download and install the app, then select the Bongolava region (as shown in the image below), and complete the user registration (Brazilian phone numbers are supported).

Test Store Registration and Location Settings

After registration, please inform Keeta of your registered phone number and the test store ID you previously created via the link. The Keeta team will bind the two for you to place test orders. After this you will be able to see the test store in the Home page and place test orders with mocked payment.

Note: Keeta's test stores are located in the Bongolava region of Madagascar. Please ensure that the delivery address for the test order is near the test store.

If your test store cannot accept orders and displays “Out of Delivery Area,” please switch your current location to a nearby point within the designated testing region.

To update your location:

  1. Tap the address in the top-right corner of the screen.
  2. Select “Tap to Change.”
  3. Tap the top-right region selector (e.g., “Brasil”).
  4. Choose the first option: “Bongolava”, then tap “Confirm.”
  5. Select any available location point within the region and tap “Confirm Location.”

Once your location is updated, you will be within the testing area and can place orders at the designated test store.

Signature Calculation

This document describes the HMAC-SHA256 signature calculation process used for API authentication. The signature is generated by combining the request URL, query parameters, and request body into a signature string, then computing an HMAC-SHA256 hash using a secret key.

Algorithm: HMAC-SHA256
Encoding: Base64
Signature Header: X-App-Signature

Time Zone Conversion

1. Time Zone Conversion Target Object

There are 3 APIs involved in time zone handling:

2. Time Zone Conversion Rules

(1) All time-related fields in the documentation are transmitted in the UTC+0 time zone.
(2) The value in timePeriods should always conform to the rule: endTime > startTime.
(3) If the time spans a day after conversion to the UTC+0 time zone, it should be split into two parts.
(4) 24:00 should be transmitted as: 23:59:00.000Z.

3. Time Zone Conversion Examples

Take Brazil's official time zone UTC-3 as an example.

3.1 [ data + timePeriod ] combination scenario

(1) The conversion to UTC+0 will not cross the day

If the local time is: **2024-04-07 08:00-20:00**, the format transmitted in the API should be (after converting to UTC+0):
[
  {
    "date": "2021-04-07",
    "timePeriods": {
        "startTime": "11:00:00.000Z",
        "endTime": "23:00:00.000Z"
    }
  }
]

(2) The conversion to UTC+0 will cross the day

If the local time is: **2024-04-07 10:00-22:00**, the format transmitted in the API should be (after converting to UTC+0):
[
  {
    "date": "2021-04-07",
    "timePeriods": {
        "startTime": "13:00:00.000Z",
        "endTime": "23:59:00.000Z"
    }
  },
  {
    "date": "2021-04-08",
    "timePeriods": {
        "startTime": "00:00:00.000Z",
        "endTime": "01:00:00.000Z"
    }
  }
]

3.2 [ dayOfWeek + timePeriod ] combination scenario

(1) The conversion to UTC+0 will not cross the day

If the local time is: **Monday & Tuesday 08:00-20:00**, the format transmitted in the API should be (after converting to UTC+0):
[
  {
    "dayOfWeek": [
        "MONDAY",
        "TUESDAY"
    ],
    "timePeriods": {
        "startTime": "11:00:00.000Z",
        "endTime": "23:00:00.000Z"
    }
  }
]

(2) The conversion to UTC+0 will cross the day

If the local time is: **Monday & Tuesday 10:00-22:00**, the format transmitted in the API should be (after converting to UTC+0):
[
  {
    "dayOfWeek": [
        "MONDAY"
    ],
    "timePeriods": {
        "startTime": "11:00:00.000Z",
        "endTime": "23:59:00.000Z"
    }
  },
  {
    "dayOfWeek": [
        "TUESDAY"
    ],
    "timePeriods": {
        "startTime": "00:00:00.000Z",
        "endTime": "01:00:00.000Z"
    }
  },
  {
    "dayOfWeek": [
        "TUESDAY"
    ],
    "timePeriods": {
        "startTime": "11:00:00.000Z",
        "endTime": "23:59:00.000Z"
    }
  },
  {
    "dayOfWeek": [
        "WEDNESDAY"
    ],
    "timePeriods": {
        "startTime": "00:00:00.000Z",
        "endTime": "01:00:00.000Z"
    }
  }
]

Finally merge into:

[
  {
    "dayOfWeek": [
        "MONDAY",
        "TUESDAY"
    ],
    "timePeriods": {
        "startTime": "11:00:00.000Z",
        "endTime": "23:59:00.000Z"
    }
  },
  {
    "dayOfWeek": [
        "TUESDAY",
        "WEDNESDAY"
    ],
    "timePeriods": {
        "startTime": "00:00:00.000Z",
        "endTime": "01:00:00.000Z"
    }
  }
]

Merchant Authorization

Merchant Adding Authorization (with APP ID)

If a merchant wants to authorize an application, the merchant should go to the App Activation tab in the Merchant Management system, and click the "Activar aplicativo" button at the top right corner of the page and follow the steps below:

  1. Enter the APP ID of the service provider's application (available from the provider).
  2. Confirm provider information to ensure accuracy.
  3. Select the store(s) to be authorized:
    • For store-level accounts, this step is skipped.
    • For brand-level accounts, the merchant must select which stores to authorize.
  4. Click Confirm to proceed.
  5. Copy authorization code(Optional) If the application you are about to authorize is an application in shop level authorization code mode, You will see the authorization_code on the page. Please copy this code and give it to the software service to complete the authorization process.
  6. Click "Registro da autorização" to automatically download an Excel file containing the authorization record
  7. Once authorization is complete:
    • The service provider's merchant operations email will receive a notification.
    • The provider's system will receive a webhook notification.
    • The provider can retrieve authorized merchant data via API.

Merchant Adding Authorization (via URL)

The service provider logs into the Keeta Dev Portal using a developer or sub-account (operations account), clicks “Add Authorization” , and shares the generated authorization URL with the merchant.

  1. The merchant opens the URL and logs in using either a brand-level or store-level account.
  2. The merchant does not need to input an APP ID—simply select the stores to authorize, and click Confirm.
  3. Copy authorization code(Optional) If the application you are about to authorize is an application in shop level authorization code mode, You will see the authorization_code on the page. Please copy this code and give it to the software service to complete the authorization process.
  4. Click “Registro da autorização” to automatically download an Excel record of the authorization.
  5. Once authorization is completed:
    • The provider’s merchant operations email will receive a notification.
    • The provider’s system will receive a Webhook notification.
    • Authorized merchant data can be retrieved via API.

After authorization, the merchant should contact the provider to complete store configuration (such as store mapping).

Merchant Revokeing Authorization

Merchants can revoke authorization using either of the following methods:

  1. Bulk revocation:

    Select the current list of stores and revoke authorization in a batch. A double-confirmation popup is required before the operation proceeds.

  2. Single revocation:

    Click the designated button and confirm to revoke authorization for an individual store.

Upon completion:

  1. An Excel file containing the operation record will be automatically downloaded for reference.
  2. The service provider's merchant operations email will receive a notification.
  3. The provider's system will receive a Webhook event.
  4. The provider will lose access to merchant store data via API.

Stay updated of merchants authorization activity

The service provider can receive notifications for merchant authorization cancellations or new authorizations via Webhook . Keeta will also send an email to the merchant operation mailbox, please check the inbox.

Or, the service provider can also view all the authorized stores in the Mapping Check in Dev Portal with detailed infomation, as mentioned above.

Merchant Self-serve Authorization

Before accessing merchant data, service providers must obtain authorization from merchants. Within the Keeta platform, it is recommended to use Merchant Self-Authorization to automate and streamline this process.

Step 1: Retrieve Authorization Link

  • Initiate Request: The service provider system calls the Keeta API to retrieve the authorization URL.

    Note: If API integration is not available, the URL can be manually acquired via the Add Authorization button on the Dev Portal.

  • Generate Link: Keeta returns an authorization link containing the required parameters.
  • Distribute Link: The service provider shares the link with the target merchant to begin the authorization flow.

Step 2: Merchant Authorization Operation

  • Access Authorization Page: The merchant clicks the link, redirecting their browser to the Keeta authorization page.
  • Authentication: The merchant logs in via Keeta, using either a Brand Account or a Store Account.
  • Store Selection: The system displays the merchant’s store list.
    • Brand account users must select the store scope to authorize.
    • Store account users will proceed without additional selection.

Step 3: Post-Authorization Handling (Two Modes)

Mode A: Redirect Integration (Automated Workflow)

  • Automatic Redirect: After authorization, Keeta redirects to the service provider system with the authId.
  • Fetch Store Info: The service provider calls the API to retrieve detailed store information.
  • Store Mapping UI: The service provider displays a mapping interface for the merchant to match their stores with the service provider’s system.
  • Integration Complete: Upon confirmation, the service provider registers store data via the onboarding API.

Mode B: Manual Mapping via Authorization Records

  • Merchant-side Download: After authorization, the Keeta merchant management system automatically downloads a spreadsheet of the authorized stores. Alternatively, merchants may manually download the store list to assist with mapping. To explore detailed functionality and operations, please log in to the merchant portal using a test store account.
  • Email Notification to Service Provider: Keeta sends the authorized store list to the merchant operations email provided by the service provider for reference and mapping.
  • View in Dev Portal: Service providers can log into the Dev Portal and use the Mapping Check feature to search for authorized store records and maintain mappings manually.

ChangeLog

Version[1.0.6] - Sep 2, 2025

  1. Added Delivered and Send Delivery Updates APIs related to "Merchant Responsible Delivery".

Version[1.0.5] - Jul 25, 2025

  1. Added Integrating with the Keeta API.
  2. Added Postman Collection.

Version[1.0.4] - Jul 18, 2025

ORDERS changes

  1. Added the post /v1/batchDecrypt endpoint.

Version[1.0.3] - Jul 8, 2025

ORDERS changes

  1. Added the post /v1/orders/{orderId}/dispatch endpoint. request validation only.

Version[1.0.2] - Jul 7, 2025

MERCHANT changes

  1. Removed the post /v1/merchantStatus/{merchantId}/available and post /v1/merchantStatus/{merchantId}/unavailable endpoints, and unified the merchant status update through the POST /merchantUpdate endpoint (consistent with the native Open Delivery protocol).

Version[1.0.1] - Jun 30, 2025

Response Body Structure Definition Change

  1. Version 1.0.0 introduced response body structural changes, while v1.0.1 was adjusted to maintain alignment with the Open Delivery.

ORDERS changes

  1. Updated order events diagram and order flow diagram in Order Overview section.
  2. Added Order Refund instruction under Order Overview which follows Keeta's refund rules.
  3. Added sample metadata for payload within USER_REFUND_REQUEST event that could be notified by polling or webhook mechanism.

MERCHANT changes

  1. The data structure and fields of GET /merchant and POST /merchantUpdate endpoints are adjusted to be consistent with the native Open Delivery protocol.
Operations
Operations

Register / Update Merchant endpoint info.

Request

Register and update the Merchant endpoint GET /v1/merchant information in Keeta.

For the Software Service, all authorized merchant will use the same token. To enable Keeta to identify which merchant needs to be registered, the Software Service must include the Keeta merchant ID in its requests. The Software Service should also save the mapping relationship between the Keeta merchant ID and its own merchant ID in the system. Merchants can obtain this merchantId from the Keeta merchant portal.

IMPORTANT:

  1. It is necessary to provide the Keeta merchant ID to ensure that the mapping between the merchant ID of Software Service and the merchantId of Keeta is accurate.
  2. If an existing Keeta MerchantId or External MerchantId under the App has been previously registered, any subsequent onboarding request containing these identifiers will result in the deletion of historical data and the creation of a new mapping configuration.
  3. Store registration via onboarding endpoint must be completed prior to order flow integration. This enables Keeta to properly identify the merchantId in your system. Otherwise, no order events will be received via polling or webhook.

HOST: Keeta

DIRECTION:

Security
OAuth2 and Sig
Query
merchantIdstringrequired

The ID of the Merchant for whom you want to complete or change registration info.

Bodyapplication/jsonrequired
getMerchantURLobject

Information about the merchant's Software Service's GET /v1/merchant access. This endpoint has the necessary information for Keeta to be able to make the merchant's available on their plataform.

ordersWebhookURLstring(uri)

Information about the merchant's Software Service's POST /v1/newEvent webhook access. This is where Keeta will sent the order's events to the Software Service as they happen.

keetaMerchantIdnumberrequired

The Keeta merchant ID is generated by Keeta. Merchants can obtain this merchantId from the Keeta merchant portal.

curl -i -X PUT \
  'https://open.mykeeta.com/api/open/opendelivery/v1/merchantOnboarding?merchantId=string' \
  -H 'Authorization: Bearer <YOUR_TOKEN_HERE>' \
  -H 'Content-Type: application/json' \
  -H 'X-App-Signature: YOUR_API_KEY_HERE' \
  -d '{
    "getMerchantURL": {
      "baseURL": "http://example.com",
      "apiKey": "string"
    },
    "ordersWebhookURL": "http://example.com",
    "keetaMerchantId": 0
  }'

Responses

Resource has been created.

Bodyapplication/json
getMerchantURLobject

Information about the merchant's Software Service's GET /v1/merchant access. This endpoint has the necessary information for Keeta to be able to make the merchant's available on their plataform.

ordersWebhookURLstring(uri)

Information about the merchant's Software Service's POST /v1/newEvent webhook access. This is where Keeta will sent the order's events to the Software Service as they happen.

keetaMerchantIdnumberrequired

The Keeta merchant ID is generated by Keeta. Merchants can obtain this merchantId from the Keeta merchant portal.

Response
application/json
{ "getMerchantURL": { "baseURL": "http://example.com", "apiKey": "string" }, "ordersWebhookURL": "http://example.com", "keetaMerchantId": 0 }

Request

Endpoint to get data of a specific merchant, such as basic info, menus, and services.

  • this endpoint can optionally require an apiKey for authentication, and the Software Service that hosts the endpoint can decide whether it is needed.
  • The Software Service can pass the data through the PUT /v1/merchantOnboarding endpoint.
  • The endpoint is designed so that each merchant has its own URL.
  • The specification recommends that the endpoint ends with the /merchant route, but this is not mandatory. The Software Service can implement the URL in any way it sees fit, as long as it contains information from only one merchant.

An item must have either a delivery price or a pickup price. Currently, item with only indoor price is not permitted.



HOST: SOFTWARE SERVICE

DIRECTION:

Security
apiKey
curl -i -X GET \
  'https://{domain_of_the_software_service}/v1/merchant' \
  -H 'X-API-KEY: YOUR_API_KEY_HERE'

Responses

Successful returns Merchant information.

Bodyapplication/json
lastUpdatestring(date-time)

The last modified date and time in ISO timestamp format but with type String. This should be used in conjuction of the TTL field to update the information on the ordering aplication. (UTC date-time in ISO timestamp format. See Guidelines for more info)."

Keeta does not support this field and will be ignored.

Example: "2021-05-27T20:45:10.332Z"
TTLinteger

Time to Live (in seconds).

  • Min: 500
  • Max: 86400

A new request must be done when the TTL expires.

Keeta does not support this field and will be ignored.

Example: 500
idstring[ 36 .. 100 ] charactersrequired

Unique Identifier. Identifies the merchant in the different systems that the merchant will communicate.
This id must be generated by the merchant's Software Service.

The software service should ensure that merchantId is unique.

If this is not possible, it is recommended to at least use a UUID.

Example: "22815773000169-dbc7e35a-c936-4665-9e13-eb55eb8b6824"
statusstringrequired

Indicates if the Merchant is Available or Unavailable. Only use this type when you must close (disable) the merchant due to an unexpected event and you don't know when the service will be re-established (e.g. do not use for holidays).

Enum"AVAILABLE""UNAVAILABLE"
Example: "AVAILABLE"
basicInfoobject(BasicInfo)required
basicInfo.​namestring<= 500 characters

Merchant Public Name

Keeta does not support this field and will be ignored.

Example: "Pizza Plaza"
basicInfo.​documentstring^\d{14}$

Merchant Document

Keeta does not support this field and will be ignored.

Example: "22815773000169"
basicInfo.​corporateNamestring<= 500 characters

Merchant Corporate Name

Keeta does not support this field and will be ignored.

Example: "Food Company"
basicInfo.​descriptionstring

Merchant Description

Keeta does not support this field and will be ignored.

Example: "Food company specializing in pizzas."
basicInfo.​averageTicketnumber(decimal)

Average Ticket. Can be used to show the price range of items available at the merchant. It is not mandatory, but recommended to be used.

Keeta does not support this field and will be ignored.

Example: 90
basicInfo.​averagePreparationTimenumber(double)

Average amount of time preparing an order takes, in minutes.

Keeta does not support this field and will be ignored.

Example: 20
basicInfo.​minOrderValueobject(Price)
basicInfo.​merchantTypestring

Merchant Type.Currently, only RESTAURANT is accepted.

Keeta does not support this field and will be ignored.

Value"RESTAURANT"
Example: "RESTAURANT"
basicInfo.​merchantCategoriesArray of strings

Merchant Categories

Keeta does not support this field and will be ignored.

Items Enum"BURGERS""PIZZA""FAST_FOOD""HOT_DOG""JAPANESE""DESSERTS""AMERICAN""ICE_CREAM""BBQ""SANDWICH"
Example: ["PIZZA","FAMILY_MEALS","PREMIUM"]
basicInfo.​addressobject(Address)
basicInfo.​contactEmailsArray of stringsrequired

Merchant Contact Emails. Only supports up to 3.

Example: ["food@company.com"]
basicInfo.​contactPhonesobject(Contact Phones)required
basicInfo.​contactPhones.​commercialNumberstringrequired

Telephone number of the merchant. Please note that the area code is required.

Example: "55-11999999999"
basicInfo.​contactPhones.​whatsappNumberstring

Whatsapp number of the merchant, Keeta will temporarily ignore this information.

Keeta does not support this field and will be ignored.

Example: "11998888888"
basicInfo.​logoImageobject
basicInfo.​bannerImageobject
basicInfo.​createdAtstring(date-time)

Merchant creation date and time. \n\n(UTC date-time in ISO timestamp format. See Guidelines for more info).

Keeta does not support this field and will be ignored.

basicInfo.​acceptedCardsArray of strings

Indicates which card brands are accepted by the merchant.

Keeta does not support this field and will be ignored.

Items Enum"VISA""MASTERCARD""DINERS""AMEX""HIPERCARD""ELO""AURA""DISCOVER""VR_BENEFICIOS""SODEXO"
servicesArray of objects(Service)required

A required entity to implement. Describes food ordering services details for a merchant.

services[].​idstringrequired

Unique Identifier

Example: "f078e8e2-3044-4eec-b4a8-8359810de123"
services[].​statusstring

Indicates if the entity is Avaliable or Unavaliable. Only use this type when you must disable the entity due to an unexpected event and you don't know when the service will be re-established (e.g. do not use for holidays).

Keeta does not support this field and will be ignored.

Enum"AVAILABLE""UNAVAILABLE"
Example: "AVAILABLE"
services[].​serviceTypestringrequired

The type of service being offered:
DELIVERY - for orders that will be delivered to the customer's address.
TAKEOUT - orders that will be picked up at the establishment by the customer
INDOOR - orders that will be consumed inside the establishment.

Enum"DELIVERY""TAKEOUT""INDOOR"
Example: "DELIVERY"
services[].​serviceTimingobject(Service Timing)

Information regarding the accepted service times.

Keeta does not support this field and will be ignored.

services[].​servicePriorityArray of strings

Indicates to the Ordering Application whether the merchant works with different order preparation and delivery priorities.
Must enter up to how many priority levels the merchant serves.
If not entered, it means that the merchant does not have any specific configuration for working with priority, and may or may not be able to do so.

Keeta does not support this field and will be ignored.

Items Enum"PRIORITY1""PRIORITY2""PRIORITY3""PRIORITY4""PRIORITY5"
Example: ["PRIORITY1","PRIORITY2"]
services[].​menuIdstringrequired

The id value of the Menu entity correlated to this Service entity.

Example: "f627ccdc-6789-456f-a782-148538d5035b"
services[].​targetAppIdstring

This field is for situations in which the merchant needs to send different menus for the same serviceType to different Ordering Applications (this can occur when there is an integration software between the merchant software and the Ordering Application). In this case this field must be filled in with the AppId of the OrderingApplication which will receive this service info.

Keeta does not support this field and will be ignored.

services[].​serviceAreaobject(Service Area)
services[].​serviceHoursobject(Service Hours)required
services[].​serviceHours.​idstringrequired

A unique identifier of the service hours.

Example: "fb093d8c-2ca5-40fb-afcf-472fbdae81cc"
services[].​serviceHours.​weekHoursArray of objects(Hours)required

A list of the day(s) of the week and time periods for which the service is valid.

services[].​serviceHours.​weekHours[].​dayOfWeekArray of stringsrequired

Day of the week for which these service hours are valid

Items Enum"MONDAY""TUESDAY""WEDNESDAY""THURSDAY""FRIDAY""SATURDAY""SUNDAY"
Example: ["MONDAY","TUESDAY","WEDNESDAY","THURSDAY","FRIDAY","SATURDAY","SUNDAY"]
services[].​serviceHours.​weekHours[].​timePeriodsobject(Time Periods)required
services[].​serviceHours.​weekHours[].​timePeriods.​startTimestring(time)required

Indicates the specific time of day in ISO format starting from which users' orders can be placed.

Example: "10:00:00.000Z"
services[].​serviceHours.​weekHours[].​timePeriods.​endTimestring(time)required

Indicates the specific time of day in ISO format beyond which users' orders cannot be placed.

Example: "18:00:00.000Z"
services[].​serviceHours.​holidayHoursArray of objects(Holiday Hours)

Map of holiday dates, each with optional timePeriods. If a date does not have a time period specified, the restaurant will be closed for that date.

menusArray of objects(Menu)required

A required entity to implement. Describes an array of menus.

menus[].​idstringrequired

A unique identifier of the menu.

Example: "f627ccdc-6789-456f-a782-148538d5035b"
menus[].​namestring<= 500 charactersrequired

Menu name

Example: "Pizzas"
menus[].​descriptionstring

Menu Description

Example: "Pizza menu"
menus[].​externalCodestringrequired

Menu External Code. (Tipically the merchant Software Service menu code)

Example: "123"
menus[].​disclaimerstring

Disclaimer.

Keeta does not support this field and will be ignored.

Example: "Lorem Ipsum is simply dummy text of the printing and typesetting industry."
menus[].​disclaimerURLstring(uri)

Disclaimer URL.

Keeta does not support this field and will be ignored.

Example: "http://example.com"
menus[].​categoryIdArray of stringsrequired

A list of the id values of the child Category entities that correspond to this Menu entity. Default assumes all Category entities are available in this menu.

Example: ["92fad022-2c28-4239-a026-989f5b555cb7","6bb71850-1d40-49f9-8046-b13e068c0cca"]
categoriesArray of objects(Category)required

A required entity to implement. Describes an array of sections in the menu where ItemOffers will be showed.

categories[].​idstringrequired

A unique identifier of the category.

Example: "92fad022-2c28-4239-a026-989f5b555cb7"
categories[].​indexintegerrequired

Category display index.

Example: 0
categories[].​namestring<= 150 charactersrequired

Category name.

Example: "Salted Pizza"
categories[].​descriptionstring

Category description.

Example: "Salted pizza flavors."
categories[].​imageobject
categories[].​externalCodestringrequired

Category External Code. (Tipically the merchant Software Service category code)

Example: "13"
categories[].​statusstringrequired

Indicates if the entity is Available or Unavailable. Only use this type when you must disable the entity due to an unexpected event and you don't know when the service will be re-established (e.g. do not use for holidays).

Enum"AVAILABLE""UNAVAILABLE"
Example: "AVAILABLE"
categories[].​availabilityIdArray of strings

The id values of Availability entities which provide details on when the category is available.

If not informed, assumes a Category is AVAILABLE at all times.

Example: ["11d063c4-73a7-4f87-a0eb-71636cc02029"]
categories[].​itemOfferIdArray of stringsrequired

A list of the id values of the child ItemOffer entities that correspond to this Category entity.

Example: ["f080cfb3-5c4a-4eb7-907d-2de3bbb5dfb9"]
itemOffersArray of objects(ItemOffer)required

A required entity to implement. Describes an array of offers for the Items.

itemOffers[].​idstringrequired

A unique identifier of the item offer.

Example: "f080cfb3-5c4a-4eb7-907d-2de3bbb5dfb9"
itemOffers[].​itemIdstringrequired

The id value of the Item entity correlated to this ItemOffer entity.

Example: "732bd31e-77fc-47ee-88ee-a0437f97b198"
itemOffers[].​indexintegerrequired

ItemOffer display index.

Example: 0
itemOffers[].​statusstringrequired

Indicates if the entity is Available or Unavailable. Only use this type when you must disable the entity due to an unexpected event and you don't know when the service will be re-established (e.g. do not use for holidays). Default is AVAILABLE.

Default "AVAILABLE"
Enum"AVAILABLE""UNAVAILABLE"
Example: "AVAILABLE"
itemOffers[].​priceobject(Item Price)required
Example: {"value":43,"originalValue":43,"currency":"BRL"}
itemOffers[].​price.​valuenumber(decimal)

The actual price value. 4 decimals places are accepted.

Keeta does not support this field and will be ignored.

Example: 43
itemOffers[].​price.​originalValuenumber(decimal)required

The orginal price value. 4 decimals places are accepted

Example: 43
itemOffers[].​price.​currencystring^[A-Z]{3}$

The 3-letter ISO 4217 currency code.

Keeta does not use this field as the currency unit and will be ignored.

Example: "BRL"
itemOffers[].​availabilityIdArray of strings

The id values of Availability entities which provide details on when the menu item offer is available.

If not informed, assumes an ItemOffer is AVAILABLE at all times.

Example: ["11d063c4-73a7-4f87-a0eb-71636cc02029"]
itemOffers[].​optionGroupsIdArray of strings

A list of the id values of the child OptionGroup entities that correspond to this ItemOffer entity.

Example: ["fe67e551-f42f-499a-8afb-0ed893c71fa3"]
itemsArray of objects(Item)required

A required entity to implement. Describes an array of items. To be used with an ItemOffer or an Option.

items[].​idstringrequired

A unique identifier of the item.

Example: "732bd31e-77fc-47ee-88ee-a0437f97b198"
items[].​namestring<= 150 charactersrequired

Item name

Example: "1/2 Pepperoni"
items[].​descriptionstring

Item Description

Example: "Pepperoni flavored pizza with LOTS of pepperoni."
items[].​externalCodestringrequired

Item External Code. (Tipically the merchant Software Service item code)

Example: "233467"
items[].​statusstringrequired

Indicates if the entity is Available or Unavailable. Only use this type when you must disable the entity due to an unexpected event and you don't know when the service will be re-established (e.g. do not use for holidays). Default is AVAILABLE.

Default "AVAILABLE"
Enum"AVAILABLE""UNAVAILABLE"
Example: "AVAILABLE"
items[].​imageobject
items[].​imagesArray of objects<= 2 items

Array of images of the item. This field should be used when you need size variations for the images.

items[].​nutritionalInfoobject(Nutritional Info)
items[].​servinginteger

Field to show the number of people the portion serves.

Example: 2
items[].​unitstring

Item's Unit of Measurement.

Possible values:

  • UN - Unit
  • KG - Kilogram (Keeta is not currently supported)
  • L - Liter (Keeta is not currently supported)
  • OZ - Ounce (Keeta is not currently supported)
  • LB - Pound (Keeta is not currently supported)
  • GAL - Gallon (Keeta is not currently supported)
Enum"UN""KG""L""OZ""LB""GAL"
Example: "KG"
items[].​eanstring

EAN (European Article Number). Keeta does not support this field and will be ignored.

Example: "7896005202074"
optionGroupsArray of objects(Option Group)

An optional entity to implement. Describes additional options of an ItemOffer.

availabilitiesArray of objects(Availability)

An optional entity to implement. Describes the time period during which a Category or an ItemOffer entity is served.

Note:
Our current menu model supports the following options for configuring product availability:
     1. Specific date ranges defined by the startDate and endDate fields
     2. A weekly schedule defined by the hours array
Combination of 1 and 2 are not supported.

Response
application/json
{ "lastUpdate": "2021-05-27T20:45:10.332Z", "TTL": 500, "id": "22815773000169-dbc7e35a-c936-4665-9e13-eb55eb8b6824", "status": "AVAILABLE", "basicInfo": { "name": "Pizza Plaza", "document": "22815773000169", "corporateName": "Food Company", "description": "Food company specializing in pizzas.", "averageTicket": 90, "averagePreparationTime": 20, "minOrderValue": {}, "merchantType": "RESTAURANT", "merchantCategories": [], "address": {}, "contactEmails": [], "contactPhones": {}, "logoImage": {}, "bannerImage": {}, "createdAt": "2021-05-10T20:45:10.332Z" }, "services": [ {} ], "items": [ {}, {}, {}, {}, {} ], "menus": [ {} ], "categories": [ {}, {} ], "itemOffers": [ {}, {} ], "optionGroups": [ {}, {} ], "availabilities": [ {} ] }

Request

POST /v1/merchantUpdate/{merchantId}

Information about a update in the systems.

This endpoint can be used in the following ways:

1 - Sent with an empty body:
This will force Keeta to make a new request to the GET /v1/merchant endpoint to update all the merchant information.

2 - Sent with only the merchantStatus field:
This will force the opening or closing of the merchant within Keeta, without forcing a new GET /v1/merchant call.

3 - Sent with only the entityType and updatedObjects fields:
This will force Keeta to update only the sent objects, without forcing a new GET /v1/merchant call.

IMPORTANT:
1- Please do not pass merchantStatus and entityType&updatedObjects at the same time. When merchantStatus has a value, the request will be regarded as updating only merchant status, and entityType&updatedObjects will be ignored.Please update merchant status and other entity separately.
2- When the entityType field is populated, the updatedObjects field cannot be empty.
3- It is recommended not to pass an empty body, but to pass a specific entity to be updated to avoid invalid update operations.
4- An item must have either a delivery price or a pickup price. Currently, item with only indoor price is not permitted.
5- The business status of a store is determined by many factors (business hours, number of items available for sale, merchant status, etc.).




HOST: Keeta

DIRECTION:

Security
OAuth2 and Sig
Path
merchantIdstringrequired

The unique identifier of the merchant. The merchantId is generated by the Software Service.

Bodyapplication/json
merchantStatusstring

Indicates if the Merchant is Avaliable or Unavaliable. Only use this type when you must close (disable) the merchant due to an unexpected event and you don't know when the service will be re-established (e.g. do not use for holidays).

Enum"AVAILABLE""UNAVAILABLE"
Example: "AVAILABLE"
entityTypestring

The entity type of the updated object.

Discriminator
updatedObjectsArray of objects

Updated Merchant entity objects

curl -i -X POST \
  'https://open.mykeeta.com/api/open/opendelivery/v1/merchantUpdate/{merchantId}' \
  -H 'Authorization: Bearer <YOUR_TOKEN_HERE>' \
  -H 'Content-Type: application/json' \
  -H 'X-App-Signature: YOUR_API_KEY_HERE' \
  -d '{
    "merchantStatus": "AVAILABLE",
    "entityType": "MERCHANT",
    "updatedObjects": [
      {
        "id": "stringstringstringstringstringstring",
        "status": "AVAILABLE",
        "basicInfo": {
          "name": "Pizza Plaza",
          "document": "22815773000169",
          "corporateName": "Food Company",
          "description": "Food company specializing in pizzas.",
          "averageTicket": 90,
          "averagePreparationTime": 20,
          "minOrderValue": {
            "value": 40,
            "currency": "BRL"
          },
          "merchantType": "RESTAURANT",
          "merchantCategories": [
            "PIZZA",
            "FAMILY_MEALS",
            "PREMIUM"
          ],
          "address": {
            "country": "BR",
            "state": "BR-SP",
            "city": "São Paulo",
            "district": "Moema",
            "street": "Plaza Avenue",
            "number": "100",
            "postalCode": "20111-000",
            "complement": "BL 02 AP 31",
            "reference": "Yellow House",
            "latitude": -23.54809,
            "longitude": -46.63638
          },
          "contactEmails": [
            "food@company.com"
          ],
          "contactPhones": {
            "commercialNumber": "55-11999999999",
            "whatsappNumber": "11998888888"
          },
          "logoImage": {
            "URL": "https://food-company.com/image.jpg",
            "CRC-32": "96b41025"
          },
          "bannerImage": {
            "URL": "https://food-company.com/image.jpg",
            "CRC-32": "96b41025"
          },
          "createdAt": "2019-08-24T14:15:22Z",
          "acceptedCards": [
            "VISA"
          ]
        },
        "services": [
          {
            "id": "f078e8e2-3044-4eec-b4a8-8359810de123",
            "status": "AVAILABLE",
            "serviceType": "DELIVERY",
            "serviceTiming": {
              "timing": [
                "INSTANT",
                "SCHEDULED"
              ],
              "schedule": {
                "scheduleTimeWindow": "15_MINUTES",
                "scheduleStartWindow": "15_MINUTES",
                "scheduleEndWindow": "15_MINUTES"
              }
            },
            "servicePriority": [
              "PRIORITY1",
              "PRIORITY2"
            ],
            "menuId": "f627ccdc-6789-456f-a782-148538d5035b",
            "targetAppId": "string",
            "serviceArea": {
              "id": "01339e6d-520b-429e-bc7c-dcfd2df42278",
              "polygon": [
                {
                  "geoCoordinates": [],
                  "price": {}
                }
              ],
              "geoRadius": {
                "geoMidpointLatitude": -23.54809,
                "geoMidpointLongitude": -46.63638,
                "radius": [
                  {}
                ]
              },
              "exclusionAreaPolygon": [
                {
                  "geoCoordinates": []
                }
              ]
            },
            "serviceHours": {
              "id": "fb093d8c-2ca5-40fb-afcf-472fbdae81cc",
              "weekHours": [
                {
                  "dayOfWeek": [],
                  "timePeriods": {}
                }
              ],
              "holidayHours": [
                {
                  "timePeriods": {}
                }
              ]
            }
          }
        ],
        "menus": [
          {
            "id": "f627ccdc-6789-456f-a782-148538d5035b",
            "name": "Pizzas",
            "description": "Pizza menu",
            "externalCode": "123",
            "disclaimer": "Lorem Ipsum is simply dummy text of the printing and typesetting industry.",
            "disclaimerURL": "http://example.com",
            "categoryId": [
              "92fad022-2c28-4239-a026-989f5b555cb7",
              "6bb71850-1d40-49f9-8046-b13e068c0cca"
            ]
          }
        ],
        "categories": [
          {
            "id": "92fad022-2c28-4239-a026-989f5b555cb7",
            "index": 0,
            "name": "Salted Pizza",
            "description": "Salted pizza flavors.",
            "image": {
              "URL": "https://food-company.com/image.jpg",
              "CRC-32": "96b41025"
            },
            "externalCode": "13",
            "status": "AVAILABLE",
            "availabilityId": [
              "11d063c4-73a7-4f87-a0eb-71636cc02029"
            ],
            "itemOfferId": [
              "f080cfb3-5c4a-4eb7-907d-2de3bbb5dfb9"
            ]
          }
        ],
        "itemOffers": [
          {
            "id": "f080cfb3-5c4a-4eb7-907d-2de3bbb5dfb9",
            "itemId": "732bd31e-77fc-47ee-88ee-a0437f97b198",
            "index": 0,
            "status": "AVAILABLE",
            "price": {
              "value": 43,
              "originalValue": 43,
              "currency": "BRL"
            },
            "availabilityId": [
              "11d063c4-73a7-4f87-a0eb-71636cc02029"
            ],
            "optionGroupsId": [
              "fe67e551-f42f-499a-8afb-0ed893c71fa3"
            ]
          }
        ],
        "items": [
          {
            "id": "732bd31e-77fc-47ee-88ee-a0437f97b198",
            "name": "1/2 Pepperoni",
            "description": "Pepperoni flavored pizza with LOTS of pepperoni.",
            "externalCode": "233467",
            "status": "AVAILABLE",
            "image": {
              "URL": "https://food-company.com/image.jpg",
              "CRC-32": "96b41025"
            },
            "images": [
              {
                "URL": "https://food-company.com/image.jpg",
                "CRC-32": "96b41025",
                "type": "main"
              }
            ],
            "nutritionalInfo": {
              "description": "Contains preservatives",
              "calories": "2000 Cal",
              "allergen": [
                "GLUTEN"
              ],
              "additives": [
                "string"
              ],
              "suitableDiet": [
                "DIABETIC"
              ],
              "isAlcoholic": false
            },
            "serving": 2,
            "unit": "KG",
            "ean": "7896005202074"
          }
        ],
        "optionGroups": [
          {
            "id": "fe67e551-f42f-499a-8afb-0ed893c71fa3",
            "index": 0,
            "name": "Choose your salted pizza flavor",
            "description": "Choose your salted pizza flavor.",
            "externalCode": "12",
            "status": "AVAILABLE",
            "minPermitted": 2,
            "maxPermitted": 2,
            "priceMethod": "SUM",
            "options": [
              {
                "id": "e5232f14-430c-4a94-8ff6-289d5a16a87a",
                "itemId": "502ecf11-0509-48ed-b63c-6211c48fd9b9",
                "index": 0,
                "status": "AVAILABLE",
                "price": {},
                "maxPermitted": 2
              }
            ]
          }
        ],
        "availabilities": [
          {
            "id": "11d063c4-73a7-4f87-a0eb-71636cc02029",
            "startDate": "2021-05-01",
            "endDate": "2021-05-30",
            "hours": [
              {
                "dayOfWeek": [
                  "MONDAY",
                  "TUESDAY",
                  "WEDNESDAY",
                  "THURSDAY",
                  "FRIDAY",
                  "SATURDAY",
                  "SUNDAY"
                ],
                "timePeriods": {}
              }
            ]
          }
        ]
      }
    ]
  }'

Responses

The change was successfully notified to Keeta, but since Keeta may be updated asynchronously, this status code does not mean that the change has been applied to Keeta.

Response
No content
Operations
Operations
Operations
Operations