` where the Partoo iframe will load:
```html theme={null}
```
Do not use `partoo-iframe` as the container ID—it's reserved internally.
Use the SDK to create and display the iframe:
```javascript theme={null}
const connectionToken = 'YOUR_CONNECTION_TOKEN';
const options = {
startPage: 'presenceManagement',
displayIntercom: false, // Optional: default is true
displayAddButton: false // Optional: default is true
};
const partooPage = Partoo.init('your-container-id', options);
partooPage.login(connectionToken);
```
This logs in the user and displays the `startPage`.
To load a business edit view directly, pass both `startPage` and `selectedBusinessId`:
```javascript theme={null}
const options = {
startPage: 'business',
selectedBusinessId: '62ba00000000000000000000',
displayIntercom: false,
displayAddButton: false
};
const partooPage = Partoo.init('your-container-id', options);
partooPage.login(connectionToken);
```
# Page Navigation
Use the `partooPage` instance to programmatically navigate:
```javascript theme={null}
partooPage.navigate('businesses'); // Go to the businesses list
partooPage.back(); // Go back to the previous page
partooPage.forward(); // Go forward to the next page
partooPage.destroy(); // Remove the iframe
```
# Next Steps
Thanks to this quick tutorial, you learned how to display your first Partoo app view thanks to the JS SDK. To build a production ready integration, you might want to check the [Integration Guide](#).
# Authenticate
Source: https://developers.partoo.co/guides/sdk/guides/authenticate
## Authenticate a User with the Connection Token
Most Partoo App views require an authenticated user. This is done using a short-lived, one-time **connection token** generated through the Partoo REST API.
### Authentication Flow
To authenticate a user:
1. Your backend requests a connection token from Partoo using the REST API.
2. You embed the token in the page rendered to your frontend.
3. Your frontend initializes the SDK and logs in the user using the token.
```javascript theme={null}
partooPage.login('your-connection-token');
```
This login call triggers the following:
* The SDK sends the connection token to the Partoo login endpoint.
* Partoo validates the token and returns a JWT.
* The user is considered authenticated until the JWT expires.
Connection tokens are **single-use** and **short-lived**. You must implement a system to regenerate a new token whenever a user accesses a protected view after the previous token expires.
```mermaid theme={null}
sequenceDiagram
participant Client
participant YourServer as Your server
participant Partoo as Partoo server
Client->>YourServer: 1. Request Partoo page using JS SDK
YourServer->>Partoo: 2. Generate connection token for user
Partoo->>YourServer: 3. Return connection token
YourServer->>Client: 4. Serve HTML with SDK and token
Client->>Partoo: 5. partooPage.login('token')
Partoo->>Client: 6. Return JWT to keep session active
```
Design your backend to detect expired JWTs and automatically request new connection tokens before loading protected views.
# Events & Callbacks
Source: https://developers.partoo.co/guides/sdk/guides/events-callbacks
## Capturing Partoo App Events with Callbacks
You can configure callbacks to be triggered when specific events occur in the embedded Partoo App. These callbacks allow your integration to respond to user actions such as creating a business, clicking links, or encountering errors.
Some callbacks are **blocking** (they prevent the default behavior unless explicitly continued), while others are **non-blocking** (the Partoo App continues its normal flow).
***
## Setting Up a Callback
Use the `.on(eventId, callback)` method from the Partoo page instance to register an event listener.
### Syntax
```javascript theme={null}
partooPage.on(eventId, callbackFunction);
```
* `eventId` — a string identifier for the event
* `callbackFunction` — a JavaScript function that receives an event-specific `data` object
### Example
```javascript theme={null}
const subscribeCallback = (data) => {
console.log('User subscribed to:', data);
};
partooPage.on('subscribe', subscribeCallback);
```
***
## Supported Callback Events
### `subscribe`
Triggered when a user clicks **Subscribe**.
```json theme={null}
{
"productName": "presence_management",
"businesses": [
{
"id": "5a2ab4edb12ff67cba1b7e1b",
"org_id": 709,
"name": "SCEP du Caire"
}
]
}
```
***
### `open_business`
Triggered when a user opens a business page.
```javascript theme={null}
// data = "5a2ab4edb12ff67cba1b7e1b"
```
***
### `business_created`
Triggered after a business is created and saved.
This callback does **not** block redirection to the business edit page.
```javascript theme={null}
// data = "5a2ab4edb12ff67cba1b7e1b"
```
***
### `business_additional_info_updated`
Triggered when additional info is updated and saved.
This is a non-blocking callback.
```javascript theme={null}
// data = { ... }
```
***
### `business_address_updated`
Triggered when address information is updated and saved.
This is a non-blocking callback.
```javascript theme={null}
// data = { ... }
```
***
### `business_contact_updated`
Triggered when contact details are updated.
This is a non-blocking callback.
```javascript theme={null}
// data = { ... }
```
***
### `business_description_updated`
Triggered when a business description is updated.
This is a non-blocking callback.
```javascript theme={null}
// data = { ... }
```
***
### `business_open_hours_updated`
Triggered when open hours are updated and saved.
This is a non-blocking callback.
```javascript theme={null}
// data = { ... }
```
***
### `error`
Triggered when a rendering error occurs (e.g. HTTP 400, 403, 404, 500).
```javascript theme={null}
// data = 403 // HTTP status code
```
***
### `no_business_click`
Triggered when the **No Business** button is clicked.
```javascript theme={null}
partooPage.on('no_business_click', () => {
// Handle click event
});
```
***
### `no_eligible_business_click`
Triggered when the **No Eligible Business** button is clicked.
```javascript theme={null}
partooPage.on('no_eligible_business_click', () => {
// Handle click event
});
```
***
### `pm_view_go_to_edit_click`
Triggered when a user clicks **Edit** in the Presence Management view.
```javascript theme={null}
partooPage.on('pm_view_go_to_edit_click', () => {
// Handle redirection to business edit
});
```
***
### `pm_view_go_to_partner_connection_click`
Triggered when a user clicks a link to go to **Partner Connection** from Presence Management.
```javascript theme={null}
partooPage.on('pm_view_go_to_partner_connection_click', () => {
// Handle redirection to connection view
});
```
***
Use callback data to sync user actions with your backend, trigger alerts, or log analytics events in real-time.
# Integration
Source: https://developers.partoo.co/guides/sdk/guides/integration
Learn how to integrate and navigate between Partoo pages inside your application using the SDK.
## Navigate Between Partoo App Pages
Use the `navigate`, `back`, and `forward` methods on the `partooPage` instance to control user navigation between embedded Partoo views.
### Basic Navigation Methods
```javascript theme={null}
// Navigate to a specific page
partooPage.navigate('reviewManagement', seedData, pageOptions);
// Navigate back to the previous page
partooPage.back();
// Navigate forward to the next page
partooPage.forward();
```
* `routeName` (string): Required route identifier for the page
* `seedData` (object): Optional data used to preload or configure the view
* `pageOptions` (object): Optional parameters such as businessId, status, etc.
📖 For the **complete list of supported routes**, see [Supported Routes](/guides/sdk/references/supported-routes).
## View Integration Examples
Each example assumes you’ve already initialized the SDK and authenticated the user:
```javascript theme={null}
const partooPage = Partoo.init('partoo-container', {});
partooPage.login('yourConnectionToken');
```
### Business List Page
```javascript theme={null}
partooPage.navigate('businesses');
```
**Available callbacks**: `subscribe`, `open_business`
### Business Edit Page
```javascript theme={null}
partooPage.navigate('business', null, { businessId: 'yourBusinessId' });
```
**Available callbacks**: ❌ None
### Add Business Page
```javascript theme={null}
partooPage.navigate('add');
```
**Available callbacks**: `business_created`
### Analytics Page
```javascript theme={null}
partooPage.navigate('analytics');
```
**Available callbacks**: ❌ None
### Presence Management Page
```javascript theme={null}
partooPage.navigate('presenceManagement');
```
**Available callbacks**:
* `pm_view_go_to_edit_click`
* `pm_view_go_to_partner_connection_click`
### Posts Page
```javascript theme={null}
partooPage.navigate('posts', null, { status: 'unpublished' });
```
Valid `status` values: `all`, `published`, `unpublished`, `pending`\
**Available callbacks**: ❌ None
### Review Management Page
```javascript theme={null}
partooPage.navigate('reviewManagement', null, { status: 'not-treated' });
```
Valid `status` values: `live`, `treated`, `not-treated`, `deleted`\
**Available callbacks**: ❌ None
### Auto Reply Settings Page - for reviews without comments
```javascript theme={null}
partooPage.navigate('reviewAutoReplyWithoutComments');
```
**Available callbacks**: ❌ None
### Auto Reply Settings Page - for reviews with comments
```javascript theme={null}
partooPage.navigate('reviewAutoReplyWithComments');
```
**Available callbacks**: ❌ None
### Review Analytics Page
```javascript theme={null}
partooPage.navigate('reviewAnalytics');
```
**Available callbacks**: ❌ None
### Review Analysis Page
```javascript theme={null}
partooPage.navigate('reviewAnalysis');
```
**Available callbacks**: ❌ None
### Review Booster Page
```javascript theme={null}
partooPage.navigate('reviewBooster');
```
**Available callbacks**: ❌ None
### Partner Connections Page
```javascript theme={null}
partooPage.navigate('partnerConnections');
```
**Available callbacks**: ❌ None
### Messaging Page
```javascript theme={null}
partooPage.navigate('messaging');
```
**Available callbacks**: ❌ None
### Bulk Update Page
```javascript theme={null}
partooPage.navigate('bulkUpdate');
```
**Available callbacks**: ❌ None
### Conversation Starters Page
```javascript theme={null}
partooPage.navigate('conversationStarters');
```
**Available callbacks**: ❌ None
### Google Verification Page
```javascript theme={null}
partooPage.navigate('googleVerification');
```
**Available callbacks**: ❌ None
### WhatsApp Settings Page
```javascript theme={null}
partooPage.navigate('whatsappSettings');
```
**Available callbacks**: ❌ None
# Partoo SDK Reference
Source: https://developers.partoo.co/guides/sdk/references/reference
## Global `Partoo`
The `Partoo` object is available globally when you include the JS SDK in your page:
```html theme={null}
```
This object exposes the `Partoo.init()` method to embed and manage Partoo views inside an iframe.
***
## `Partoo.init(divId, options)`
Initializes a Partoo App instance by inserting an iframe into the specified DOM element.
### Parameters
ID of the target `` where the iframe will be rendered.
Optional configuration object. See [Options](/guides/sdk/references/reference#options) for details.
### Returns
Returns a `Page` object used to interact with the embedded iframe.
```javascript theme={null}
const partooPage = Partoo.init('your-container-id', options);
```
***
## Page
The `Page` object returned by `Partoo.init()` provides methods for navigation, authentication, event handling, and more.
```javascript theme={null}
const partooPage = Partoo.init('divId');
```
### Methods
#### `setOptions(options)`
Updates the iframe configuration after initialization.
Options object to update the view behavior. See [Options](/guides/sdk/references/reference#options).
***
#### `login(connectionToken)`
Authenticates the user and navigates to the defined `startPage`.
One-time connection token generated from the Partoo API.
```javascript theme={null}
partooPage.login('your-connection-token');
```
***
#### `navigate(route, seedData, additionalParams)`
Navigates to a specific page in the Partoo App.
Target page identifier. See [Supported Pages](/guides/sdk/references/supported-routes).
Deprecated.
Page-specific parameters (e.g. `businessId`, `status`, etc.).
```javascript theme={null}
partooPage.navigate('business', null, { businessId: 'abc123' });
```
***
#### `back()`
Navigates to the previous page in iframe history.
```javascript theme={null}
partooPage.back();
```
***
#### `forward()`
Navigates forward in iframe history (opposite of `back()`).
```javascript theme={null}
partooPage.forward();
```
***
#### `on(eventId, callback)`
Registers a callback function for a specific event triggered in the Partoo App.
ID of the event. See [Available callback events](/guides/sdk/guides/events-callbacks).
Function triggered when the event occurs. Receives event-specific `data`.
```javascript theme={null}
partooPage.on('subscribe', function(data) {
console.log('Subscription data:', data);
});
```
***
## Options
The `options` parameter is accepted by both `Partoo.init()` and `setOptions()`:
```javascript theme={null}
const options = {
startPage: 'businesses',
displayIntercom: false,
selectedBusinessId: 'abc123',
// more options...
};
const partooPage = Partoo.init('partoo-container', options);
partooPage.setOptions(options);
```
### Configuration Fields
| Parameter | Type | Default | Description |
| - | - | - | - |
| `startPage` | `string` | `businesses` | Initial route displayed after login |
| `startPageAnchorParam` | `string` | `null` | Anchor parameter appended to login URL |
| `displayIntercom` | `boolean` | `true` | Show or hide the Intercom help widget |
| `displayAddButton` | `boolean` | `true` | Show or hide the add business button on the top banner |
| `displayPresenceManagementDownload` | `boolean` | `true` | Show or hide the download button on Presence Management view |
| `displayBusinessModalFilters` | `boolean` | `true` | Show or hide business filters on relevant pages (e.g. Posts, Reviews, Messaging) |
| `displayVerificationRequiredButton` | `boolean` | `false` | Display a verification banner in business list and business pages |
| `selectedBusinessId` | `string` | `null` | Preselect a business on applicable views (e.g. Review, Messaging). Use `null` to reset |
Use `setOptions()` if you need to update configuration dynamically after initialization.
# Supported Routes
Source: https://developers.partoo.co/guides/sdk/references/supported-routes
Reference of all available Partoo routes, including parameters, view descriptions, and authentication requirements.
## Overview
This page provides the **complete list of available Partoo pages (routes)** that can be embedded via the SDK.\
Each entry details its :
* the **route name** to pass to `navigate()`
* supported **seedData** and **pageOptions**
* a **description of the view**
* whether **authentication is required**
## Supported Pages and Routes
| Route Name | seedData | pageOptions | View Description | Auth |
| - | - | - | - | - |
| `businesses` | `null` | `null` | List of user’s businesses | ✅ |
| `business` | `null` | `{ businessId: string }` | Edit view of a specific business | ✅ |
| `add` | `null` | `null` | Add a new business | ✅ |
| `analytics` | `null` | `null` | Analytics dashboard | ✅ |
| `presenceManagement` | `null` | `null` | Presence Management view | ✅ |
| `posts` | `null` | `{ status: string }` | Posts management view | ✅ |
| `reviewManagement` | `null` | `{ status: string }` | Review management interface | ✅ |
| `reviewAutoReplyWithoutComments` | `null` | `null` | Auto reply settings page for reviews w/o comments | ✅ |
| `reviewAutoReplyWithComments` | `null` | `null` | Auto reply settings page for reviews with comments | ✅ |
| `reviewAnalytics` | `null` | `null` | Review analytics dashboard | ✅ |
| `reviewAnalysis` | `null` | `null` | Review analysis dashboard | ✅ |
| `competitorsAnalytics` | `null` | `null` | Competitor analytics dashboard | ✅ |
| `competitorsAnalysis` | `null` | `null` | Competitor analysis dashboard | ✅ |
| `reviewBooster` | `null` | `null` | Review booster tool | ✅ |
| `partnerConnections` | `null` | `null` | Google & Facebook connection settings | ✅ |
| `messaging` | `null` | `null` | Messaging dashboard | ✅ |
| `bulkUpdate` | `null` | `null` | Bulk update view | ✅ |
| `conversationStarters` | `null` | `null` | Conversation starter settings | ✅ |
| `googleVerification` | `null` | `null` | Google verification setup | ✅ |
| `whatsappSettings` | `null` | `null` | WhatsApp settings | ✅ |
| `widgetSettings` | `null` | `null` | Widget settings page | ✅ |
# Welcome
Source: https://developers.partoo.co/index
Build with the Partoo API v2. Manage locations, reviews, messaging, and more — securely and at scale.
![Partoo]()
![Partoo]()
# Build with the Partoo API
Manage locations, reviews, messaging, and more — securely and at scale.
Explore API use cases
Make your first API call in minutes.
Explore the advanced features available in Partoo.
Integrate and scale using our API and SDKs.
Connect any messaging channel to Partoo.
Manage SSO via our API.
Manage Webhooks via our API.
Explore core concepts
Understand Providers, Organizations, Groups, Businesses, and Users.
See who can read and write which resources.
Errors, rate limits, security, and retry strategies.
Workflow for adding, updating, or removing users.
Quick links
Browse the different endpoints and try requests.
See what’s new and what changed.
# How to get help?
Source: https://developers.partoo.co/misc/help/how-to-get-help
Learn the proper way to ask for help via email, including escalation paths and the required information for faster resolution.
## Facing an Issue? Here’s What to Do
If you encounter an issue or have a question while using Partoo, follow these steps in order. The list is organized from **fastest to slowest resolution time**.
Use the search bar in this documentation to find answers to your question.
The documentation is updated regularly to cover the most common issues and questions.
Before reaching out, verify that our services are fully operational by visiting our [status page](https://status.partoo.co/).\
Updates about potential incidents or ongoing resolutions are posted there in real time.
For support via email, contact us at: [api@partoo.fr](mailto:api@partoo.fr)
Make sure to include all the required information listed below to help us respond quickly and accurately.
## Urgent Issues
An **urgent issue** means:
* It occurs **only** in the `production` **environment**.
* Your integration or bot was working fine previously.
* Suddenly, something stopped working and this directly impacts your users.
Also, we kindly ask you **not to send meeting requests** right away.
Our policy is to first exchange details by email to make sure we fully understand the situation without overloading our developers.
If, after these exchanges, the issue is still blocking, we will of course be happy to schedule a meeting.
For urgent issues, **send your report directly** to [api@partoo.fr](mailto:api@partoo.fr) and copy your Account Manager.
## Information Required in Your Request
When sending an email, please include the following information that help us quickly understand and resolve your request :
* Your **entity name** (client name)
* Give your **full name** (first name + last name)
* If you are reporting a problem for another person, please mention the **first name, last name and email address** of the person concerned by the problem.
* Your **subscription type** (e.g., pm, rm, rb, bm)
* A **clear explanation of your problem or need**
* **Impacted feature(s)** (e.g., post creation, edit business information, etc.)
* **Steps to reproduce** the issue
* The **expected behavior** vs. the **actual behavior**
* Any **error messages or logs**
* The **API calls performed**, with:
* Endpoint(s)
* Payload (if applicable)
* Timestamps of the requests
* The **environment** where the issue occurs (`production`, `sandbox`)
* Relevant **screenshots** or **screen recordings**
The more complete your request, the faster we can provide you with an accurate solution.
# Example of a Perfect Support Email
Below is a model email you can adapt to your case. It contains all the required details.
```text theme={null}
To: api@partoo.fr
CC:
Subject: [Acme Corp] Issue with Post Creation Feature in Production
Hello Partoo Support Team,
I am experiencing an issue with the **Post Creation feature**.
- **Entity name**: Acme Corp
- **Affected person**: John Doe - john.doe@acme.com
- **Subscription type**: pm
- **Environment**: Production
**Problem description**
Until this morning, everything was working fine. Starting from 09:30 CET, our requests to create posts started failing.
**Steps to reproduce**
1. Send a POST request to `/posts/create` with a valid payload.
2. Observe the response.
**Expected behavior**
The request should return `200 OK` and confirm post creation.
**Actual behavior**
We receive a `400 Bad Request` error.
**Error details**
{
"error": {
"authorization": "Operation not allowed"
}
}
**API calls performed**
- Endpoint: `POST /posts`
- Timestamp: 2025-09-10T09:30:02Z
- Payload:
{
"business_search": {
"business__in": [
[
"5409c35a97bbc544d8e26737",
"595badaef348ab6b3530033f",
"59d53302b12ff6429f262639"
]
],
... (rest of payload)
}
}
I have attached screenshots of the failed requests for reference.
Could you please investigate and advise on the root cause? Since this impacts our production environment, I would appreciate an urgent resolution.
Thank you,
John Doe
Lead Developer – Acme Corp
john.doe@acme.com
```
By following this structure, your request will be processed more efficiently and resolved faster.
# OpenAPI file
Source: https://developers.partoo.co/misc/help/openapi-download
View or download the Partoo REST API OpenAPI specification file in YAML format.
## Access the OpenAPI Specification
The OpenAPI specification defines all endpoints, parameters, request/response schemas, and authentication methods for the Partoo REST API.
You can view the specification in an API tool or download it for offline use. Here's how:
* **Download the complete YAML file**
* **Import it into an OpenAPI-compatible tool** (Postman, Insomnia, Swagger UI, etc.)
* **Use it to automatically generate an API client (SDK)**
***
## Download the OpenAPI File (YAML)
Download the full bundled OpenAPI specification:
Download OpenAPI Specification (YAML)
The file downloads as a `.yaml` document and is ready to use in compatible API tools.
***
## View the Specification in an API Tool
After downloading the file, you can import it into your preferred API tool.
### Example: Import into Postman
Launch the Postman application.
Click **Import**, then select the `openapi-bundled.yaml` file.
Postman automatically creates a collection containing all available API endpoints.
You can see all API routes listed in your workspace.
***
## Generate an API Client Automatically
You can use the OpenAPI specification to generate a typed SDK client.
### Example with OpenAPI Generator (CLI)
```bash theme={null}
openapi-generator-cli generate \
-i openapi-bundled.yaml \
-g typescript-axios \
-o ./partoo-api-client
```
This command generates a TypeScript client based on the official API definition.
Always use the latest version of the OpenAPI file to ensure compatibility with recently added or updated endpoints.
***
## Need Help?
If you encounter issues while importing or generating a client:
* Verify that the YAML file is valid
* Ensure your OpenAPI tool supports the specification version
* Check the official documentation of the tool you are using
The OpenAPI specification reflects the current version of the Partoo REST API.