# PushPushGo Documentation

## Platforms

<table data-card-size="large" data-view="cards"><thead><tr><th></th><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Web push</strong></td><td>Push notifications in browsers</td><td></td><td><a href="/pages/YmxS3LiNE89Ka031nnQQ">/pages/YmxS3LiNE89Ka031nnQQ</a></td></tr><tr><td><strong>Google Android</strong></td><td>Push notifications in mobile applications</td><td></td><td><a href="/pages/3oGKNAuKOTxliUNmjG15">/pages/3oGKNAuKOTxliUNmjG15</a></td></tr><tr><td><strong>Apple iOS</strong></td><td>Push notifications in mobile applications</td><td></td><td><a href="/pages/KUaUjzBQw4z3usWht4nK">/pages/KUaUjzBQw4z3usWht4nK</a></td></tr><tr><td><strong>Huawei Android</strong></td><td>Push notifications in mobile applications</td><td></td><td><a href="/pages/Oam0mGvZOe2aZ7yc4eFF">/pages/Oam0mGvZOe2aZ7yc4eFF</a></td></tr></tbody></table>

## Discover PushPushGo

<table data-view="cards"><thead><tr><th></th><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Subscribers</strong></td><td>Collect and get to know your audience</td><td></td><td><a href="/pages/TNQ7oZKVuwSd6y6ICWDd">/pages/TNQ7oZKVuwSd6y6ICWDd</a></td></tr><tr><td><strong>Campaigns</strong></td><td>Send push notifications to your subscribers</td><td></td><td><a href="/pages/46YrAG7ncRrebewcJ0F2">/pages/46YrAG7ncRrebewcJ0F2</a></td></tr><tr><td><strong>Scenarios</strong></td><td>Follow users’ paths for continuous engagement</td><td></td><td><a href="/pages/ARdK16h7TkJl2E1BqYuf">/pages/ARdK16h7TkJl2E1BqYuf</a></td></tr><tr><td><strong>Analytics</strong></td><td>Gain clear insights into outcomes and key metrics</td><td></td><td><a href="/pages/Mf2kv2tC2clRc2GGC4iF">/pages/Mf2kv2tC2clRc2GGC4iF</a></td></tr><tr><td><strong>Account</strong></td><td>Manage profile, payments, access and notifications</td><td></td><td></td></tr><tr><td><strong>Release notes</strong></td><td>Our latest updates</td><td></td><td><a href="/pages/-MlJYZjM0QZjaTwh-pJA">/pages/-MlJYZjM0QZjaTwh-pJA</a></td></tr></tbody></table>

## Integrations

<table data-card-size="large" data-view="cards"><thead><tr><th></th><th></th><th></th><th data-hidden data-card-target data-type="content-ref"></th></tr></thead><tbody><tr><td><strong>Webhooks</strong></td><td>Real-time communication between applications</td><td></td><td><a href="/pages/-M_uFGkutWgFQObKi8_m">/pages/-M_uFGkutWgFQObKi8_m</a></td></tr><tr><td><strong>Rest API</strong></td><td>Connect easily with other systems using PushPushGo API</td><td></td><td><a href="https://swagger.pushpushgo.com/">https://swagger.pushpushgo.com/</a></td></tr></tbody></table>


# Overview

PushPushGo enables collecting subscribers, sending push notifications and many more for websites in multiple browsers:

* Chromium-based browsers like Chrome or Opera,
* Safari (since version 16),
* Edge,
* Firefox,
* any other browser that uses [PushAPI](https://www.w3.org/TR/push-api/) and service workers.

{% hint style="info" %}
Safari from version 16.4 supports iOS push notifications. [See requirements](/web-push/safari-support).
{% endhint %}

To use our application functionalities, the following are needed:

* PushPushGo service worker for registering subscribers and delivering push notifications,
* PushPushGo integration script or SDK for managing subscriptions and collecting subscribers' data.

Depending on the project's characteristic, there are two possible integration strategies - Integration with own domain or Basic integration.

### Integration with own domain

Integration with own domain requires:

* placing service worker file on the server,
* placing integration script in the source code or implementing SDK,
* having a website with an SSL certificate.

This strategy allows:

* to subscribe with just one click through browser's default form,
* to export the collected subscriber database.

{% hint style="warning" %}
All Safari browser versions require user gesture (click on desktop, tap on mobile device)  to display subscription prompt.
{% endhint %}

### Basic integration

Basic integration only requires placing integration script in the source code while service worker is placed on PushPushGo server on a dedicated subdomain, e.g. www-website-address-com.pushpushgo.com.

This strategy is suited for:

* websites without SSL certificate,
* websites built with marketing tools.

However, there are some limitations:

* users have to subscribe in two steps: first step is accepting custom subscription form, then accepting browser's default form in a confirm window,
* subscriber database export is not available since service worker is not registered on owned domain.


# Instructions

A detailed explanation of the integration can be found at: <https://www.youtube.com/watch?v=xyPapl--NnE&t=109s&ab_channel=PushPushGo>

#### Basic integration <a href="#id-4g5amsm6sun3" id="id-4g5amsm6sun3"></a>

In the case of Basic integration, you only have to paste the integration code anywhere into your website's code. In the result:

* Your recipients will sign up in two stages. After accepting the subscription form, a second pop-up window will appear, in which users must confirm their consent to receive notifications.
* Recipients are saved on a subdomain dedicated to each project [www.yourdomain-pl.pushpushgo.com](http://www.yourdomain-pl.pushpushgo.com).
* Notifications will display a dedicated subdomain [www.yourdomain-pl.pushpushgo.com](http://www.yourdomain-pl.pushpushgo.com).

1\. To use this integration, paste the integration script anywhere in the source of your site.

![](/files/9ShmwR8Xlx1eSFTDGug5)

<figure><img src="/files/N1PUQhueTXOaOskp6hAC" alt=""><figcaption></figcaption></figure>

2\. Click the Check Integration button to verify that everything works correctly.

The following messages will inform you about the correct integration:

![](/files/Ar9pDiVFsHx11vNSyf2q)

#### Integration with own domain <a href="#njoignc1nywu" id="njoignc1nywu"></a>

In the case of Integration with own domain, additional conditions must be met during the integration process:

* Your domain must have https.
* The integration script must be placed in the \<head> section of your website's code.
* You must add an sw\.js file downloaded from our website to your server root path (so that it is available from <https://yourdomain.com/sw.js>).
* Due to the above, it is not possible to carry out this integration using Google Tag Manager.

What do you gain from this integration?

* Your recipients subscribe to one-click notifications, enabling your database to grow faster.
* Only your domain is visible in notifications on your website.

1\. To integrate your website using Integration with own domain, first download and unpack the script and then place it on the server root path.

To check its location:

* Paste http: //yourdomain/sw\.js in your browser and check if it returns the file value or displays an error

2\. Next, place the integration code in the \<head> section in your page code and click Check Integration to verify its accuracy.

![](/files/pUzWOE3svec1n1Syz8fa)

<figure><img src="/files/3CKgbuWBP4E4DFjveTkF" alt=""><figcaption></figcaption></figure>

3\. A green message will inform you about the correct integration and a form for subscribing to web push notifications will appear on the website.

![](/files/6W9bUgNw9YGaMT3lUXZj)

**Important!** In the case of integration with own domain, if you already have your service worker on the site and you can not delete it - import the contents of the sw\.js file into your file and be sure to inform us about it.

Service worker path change

If you want to replace the address from sw\.js with another one, e.g. service-worker.js, you can paste the new address in the Service Worker Path section of the Project settings tab. However, if you want to change the directory where the sw\.js file is located (for example to static/sw\.js), you must also add the following response header: "Service-Worker-Allowed": "/".

If you intend to add the service worker to another directory, e.g. static, then the fields "sw\.js path" and "sw\.js scope" (in the Project settings tab on your account) should be completed in this way:

● sw\.js path: /static/sw\.js

● sw\.js scope: /static

<figure><img src="/files/mCtoaAxbrcI2aHdkiQno" alt=""><figcaption></figcaption></figure>


# Subscription tests

In order to check whether you are subscribed for notifications on a given browser, use the test mode. To enter the site in test mode, add ppg\_test\_mode=on to the link and refresh the page. For example, on the fictitious website [www.mypage.com](http://www.mypage.com), the link would look like this: *[www.mypage.com?ppg\\\_test\\\_mode=on](http://www.mypage.com?ppg\\_test\\_mode=on)*.

The green panel at the bottom of the page indicates that you are able to enter test mode. It contains information about whether you already subscribed to notifications, your subscriber ID, and test tags that have been marked.

![Testowanie](/files/qExm5oIM2TAuX8kU35WS)


# Service worker

“A service worker is an event-driven worker registered against an origin and a path. Service workers essentially act as proxy servers that sit between web applications, the browser, and the network (when available). They are intended, among other things, to enable the creation of effective offline experiences, intercept network requests and take appropriate action based on whether the network is available, and update assets residing on the server. They will also allow access to push notifications and background sync APIs.” - [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API)

Our service worker implementation is based only on [Push API](https://developer.mozilla.org/en-US/docs/Web/API/Push_API).

If the user agrees to receive notifications through subscription form, then:

* service worker is registered in the user's browser,
* random Subscriber's Token with its VAPID key pair for data encryption is generated by provider and sent through HTTP request to the PushPushGo server,
* subscriber is saved in the PushPushGo database by giving them an internal Subscriber ID which is returned in response and saved in IndexedDB for further identification,
* based on HTTP headers, the subscriber is labeled in the PushPushGo database (operating system, language, browser, provider type, location guessed using GeoIPLookup).

In other words, the service worker is responsible for subscriber’s identification and notification delivery.


# Subdomains / Wildcards

How to setup worker in one file for multiple subdomains

## 🛠️ Configuring a Single Service Worker for Multiple Projects

This guide explains how to configure one `sw.js` file to support **multiple PushPushGo projects** using **subdomain-based mapping**. This is useful when you want to serve different push notification configurations for various portals under the same root domain (e.g., `*.example.com`) **without generating a separate worker file for each project**.

***

### 📦 Use Case

You're managing several web portals like:

* `aaa.example.com`
* `bbb.example.com`

Each of these should receive push notifications from a **separate PushPushGo project**.

***

### 🧠 Solution

Instead of dynamically generating `sw.js` for each subdomain, you can configure the service worker once and let it **dynamically import the correct PushPushGo worker script based on the current hostname**.

***

### 📄 Example `sw.js` Implementation

```js
// Map subdomains to PushPushGo project IDs
const idsMap = {
  'aaa.example.com': 'firstProjectId', // Replace with real ID
  'bbb.example.com': 'secondProjectId', // Replace with real ID
  // Add more domains as needed
};

let id = null;

// Determine the current subdomain
if (idsMap[self.location.hostname]) {
  id = idsMap[self.location.hostname];
}

if (id) {
  // Import the correct PushPushGo worker
  importScripts(`https://s-eu-1.pushpushgo.com/${id}/worker.js`);
} else {
  console.warn('[PushPushGo] No project ID configured for this domain:', self.location.hostname);
}
```

***

### 🔒 Notes

* The service worker is **cached by browsers for up to 24 hours**, and it is re-fetched when:
  * The user first visits the site,
  * A push notification is delivered,
  * Or the browser refreshes the worker during its update cycle.
* This solution ensures **separation of concerns** without server-side logic or full app bootstrapping.
* If you manage a large number of subdomains, consider fetching the mapping from a remote JSON endpoint instead of hardcoding it.

***

### 🔪 Debugging Tips

* Use browser DevTools → **Application → Service Workers** to inspect the registration and activity of the worker.
* Make sure the worker is served with proper `Content-Type: application/javascript` and over HTTPS.

***

### ✅ Advantages

* ✅ Single worker script for all portals
* ✅ No dynamic server-side rendering needed
* ✅ Scalable and cache-efficient
* ✅ Supports clean and secure push notification routing

***

### 📞 Need Help?

For support or integration questions, contact the PushPushGo team or your technical lead.


# Integration script

PushPushGo integration script is a script responsible for website settings in terms of:

* subscription form - pop-up displayed to a user asking consent to receive notifications,
* geolocation - pop-up displayed after user has subscribed to notifications, asking for the user's permission to share his location and saving the location based on[ GeoLocation API (W3C)](https://www.w3.org/TR/geolocation/),
* Google Analytics - sending events to Google Analytics,
* Data Layer - sending events to Data Layer,
* beacons - collecting subscriber's session data and, if configured, information from selectors,
* default notification - displaying default notification to subscriber if due to technical reasons, it is not possible to display original content,
* service worker path - defining service worker file path and scope,
* bell widget - a widget that allows users to consent to receive notifications.

These settings can be configured in the project settings in the PushPushGo app.


# Subscription form

The subscription form appears after you successfully integrate your page.

\
Users can agree to receive notifications with one click on a default browser pop-up in the upper left corner of a browser or double opt-in through a subscription form.

<figure><img src="/files/wJBeTez74xdimtvIwngc" alt=""><figcaption></figcaption></figure>

It's impossible to change the default browser form's appearance, but you can customize if and when the default form will appear after the user visits your website.

The subscription form can be fully customized. Bear in mind that it's only visible during the two-step subscription - the user has to agree to receive notifications through the subscription form, then through the default browser form.

The first option is available only for project integrated with own domain strategy since service worker is placed on the same domain as the integration script.

In basic integration, when a user agrees to receive notifications through the subscription form, a window opens where they have to agree to receive notifications default browser pop-up from PushPushGo subdomain since this is where the service worker will be registered.


# Subscription form creator

There are two types of templates of subscription form at your disposal: default and custom subscription form.&#x20;

\
The custom template can be enriched with advanced graphic options, including choosing a font, background color, border, size, and animation of pop-up appearance on the page.&#x20;

![](/files/rj5SeGhWkPrGubL3F90u)

**Custom subscription form options**

<figure><img src="/files/gPIOKVWJBzL6EY2WQzl9" alt=""><figcaption></figcaption></figure>

* Header

Add a title to your pop-up and choose the color, font type, size, and alignment for it.

<figure><img src="/files/00Ywou1cpnDXJ4Gnlg6c" alt=""><figcaption></figcaption></figure>

* Description

Add content to your form using the same options as in the Header section.

<figure><img src="/files/V0YzsSGGW8VAn77jYB9G" alt=""><figcaption></figcaption></figure>

* Buttons

This option allows you to specify the appearance of action buttons on the sign-up form. You can adjust shape, color, and the effect appearing when a user hovers over a button.

<figure><img src="/files/g1FA3d2C5rHNwVg5FkKw" alt=""><figcaption></figcaption></figure>

* Image

Add graphics that appear next to the text, manage its size, placement, and vertical position of the graphics.&#x20;

![](/files/wT3Y1OlgHqpExOnbHZA1)

* Form style

Specify the size and shape of the form, background color, placement on the page, animation and spaces between content and buttons.

![](/files/XDw9ogoPmGLQhknpB0Bw)

* Backdrop

The appearance of the sign-up form on the page may be accompanied by a darkening of the site's background - to do this, select the "color" option in the backdrop section. For a more subtle approach, select the "Shadow" option. You can also display the form without changing the background.

<figure><img src="/files/rLQ3Rtb1Tv0ehYAZ3tvW" alt=""><figcaption></figcaption></figure>

* Show on mobile

This step allows you to enable the sign-up form on mobile devices. You can also choose to hide the sign-up form on mobile devices and display it only on desktops and tablets.

![](/files/LTEfdgC31fWCVYTbYXx8)

You can check the result of your work in the window on the right side or by clicking the "Full desktop preview" button.

![](/files/hLvitp8aVJiSi49smXX3)


# Topics

This option allows your subscribers to choose the topic they are interested in and want to receive push notifications about.&#x20;

This can be used in the double opt-in subscription form (the custom one), or with a single opt-in subscription form, by upgrading the bell widget (you must enable both options, [bell widget](/web-push/integration-script/bell-widget) and topics)

To enable topics on your project, go to *Settings > Integration Web Push (VAPID) > Topics.*

<figure><img src="/files/VKsaDrkgX8NhLtPZ7c5k" alt=""><figcaption></figcaption></figure>

Type in the names of topics and label keys. Hit the **Save changes** button. From that point, topics will be automatically shown after configuring and publishing a double opt-in subscription form and/or a bell widget.&#x20;

Go to S*ettings > Integration > Subscription form.* Choose the Custom subscription form and fill it in.

<figure><img src="/files/CFviouu7eavNcHa0jSHJ" alt=""><figcaption></figcaption></figure>

Don't forget to publish your new subscription form!


# Subscription form delay

### Time after which the form will appear <a href="#u3f9yq97n1e8" id="u3f9yq97n1e8"></a>

You can set up the time (in seconds) between the users' entrance on the website and the subscription form apperance.

<figure><img src="/files/yDWGP0jyuR8owQgcZeGs" alt=""><figcaption></figcaption></figure>

### Reopen time <a href="#top3n8wrepj9" id="top3n8wrepj9"></a>

In Basic Integration, it is possible to display the form again after the initial rejection. For example, the user will be offered another sign-up form for notifications every 60 days.

This option is not available for integration with own domain. A default browser subscription form gives users the option of clicking the Block button, which means that the form will never be displayed again on this page and in this browser.

![](/files/HjxNAL5JHvFoKeBIgkPa)


# Display form rules

In the Display rules section you can create the appropriate rules for the sign-up form and select the subpages on which it will not be displayed.

![](/files/28pE41niBeT4TS4sNwtl)

Please note, that if you do not indicate any subpages, the form will be displayed on every subpage of your website. You can add more rules at any time using the "New rule" button.

To check if the form is displayed correctly on particular subpages of your site, you can paste the link in the **Test display rules** field and press "Save changes" button.

![](/files/U8cWkiFGu6kE8vKDAPIE)


# Confirmation window

With basic integration, the notification entry consists of two steps. After displaying the subscription form with which the user agrees to receive notifications, an additional confirmation window will appear, in which they must confirm their consent to subscribe once again.

The "Confirmation window" editing option can be found in the "Web push integration" section. You can change the content and set the logo of your project to personalize the confirmation window and make it visually consistent with the sign-up form.

<figure><img src="/files/Tl84sJiFdnocA9BbQrxo" alt=""><figcaption></figcaption></figure>


# Bell widget

The bell widget is another way of promoting signups. After clicking on a bell icon on a page, a pop-up will appear, inviting the user to become a subscriber.&#x20;

<figure><img src="/files/GzsxvXGjlzBH9G9oF4m8" alt=""><figcaption></figcaption></figure>

To enable and configure the Bell widget go to the "Integration" tab > Web Push > Bell widget. Here you can add custom texts displayed to the user, the color of the bell icon, and the button text.

<figure><img src="/files/cvi881TU3ciCrraia2rR" alt=""><figcaption></figcaption></figure>

Users who have not yet subscribed will see text encouraging them to do so.

After signing up, a box will confirm the new subscription, also providing the subscriber with an unsubscribe link.

<figure><img src="/files/opvChdWtL4iJ5uN0DiOA" alt=""><figcaption></figcaption></figure>


# Inbox

This feature can be implemented as an upgrade to the bell widget. It allows your subscribers to access past notifications from a chosen period. No more missed breaking news or lost discount codes. Inbox gives your visitors a new way of interacting with notifications - on their own terms.&#x20;

Furthermore, the Inbox increases the reach and visibility of your web push campaigns for subscribers visiting your website.&#x20;

<figure><img src="/files/Kx9edVxkhjGwA4LlYmvT" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/NF5yQpALndmaJnv1kofY" alt=""><figcaption></figcaption></figure>

You can decide how long notifications can be stored in the Inbox. To set up a timeframe, go to *Project >* *Settings > Integration > Inbox*. This option will help you keep the communication time-relevant.&#x20;

<figure><img src="/files/ExdPauqLJBBIvqNgIiQf" alt="" width="338"><figcaption></figcaption></figure>

Subscribers can also remove previously seen notifications from the Inbox by clicking the "X".&#x20;

<figure><img src="/files/DDc8vwBQQKgOcu6SpBgO" alt="" width="293"><figcaption></figcaption></figure>


# Topics

You can use this option with your [single opt-in subscription form](/web-push/integration-script/subscription-form) or  [double opt-in subscription form](/web-push/integration-script/subscription-form).&#x20;

If you choose a single opt-in form, the subscriber can configure or change preferred topics only in the bell widget

<figure><img src="/files/Nvzr7t2IRB1d7ZNBAT9i" alt=""><figcaption></figcaption></figure>

In case of a double opt-in subscription form, you can also ask users about their preferred topics as they agree to receive notifications via the form itself. See [Subscription form creator topics](/web-push/integration-script/subscription-form/subscription-form-creator/topics) for more information.&#x20;

Every subscriber who chooses their preferred topics will receive a label (or labels) *sys.topic*. See how to configure this option under [Topics](/web-push/integration-script/subscription-form/subscription-form-creator/topics).


# Google Analytics & Google Tag Manager

<figure><img src="/files/fJeja41fU9xEd1MLulP2" alt=""><figcaption></figcaption></figure>

Using these options, you can send more advanced information to your Google Analytics dashboard or capture it through Data Layer. This data includes:

* how many people clicked "Allow" in the signup form
* how many people clicked block in the signup form
* how many people closed the signup form
* how many people clicked "Allow" in the inbox
* how many people unsubscribed from the inbox
* how many people clicked the bell widget

You can find more information about Events in Google Analytics[ here](https://developers.google.com/analytics/devguides/collection/analyticsjs/events?hl=en).

If you are using several trackers in your Analytics, you can, in the field next to the checkbox, provide the name of the tracker to which events are to be sent. By specifying the name of the tracker, events will be sent as follows:

<figure><img src="/files/xDSblAkInK90FpAqzZvY" alt=""><figcaption></figcaption></figure>

<br>


# Default notification

<figure><img src="/files/rQhMk1IoUwbd5haAt4H2" alt=""><figcaption></figcaption></figure>

&#x20;If a campaign cannot be displayed (e.g., due to technical issues), subscribers will receive a default notification saying, "Your site has been updated in the background." This behavior is determined by browser settings.

To provide your subscribers with a more informative message, you can customize the “Default notification” title and content. For example, you could set a message like, "Check out our latest offers and promotions." This customized notification will automatically be displayed if technical difficulties prevent original campaign from being delivered.


# Beacons

Beacons are used to send data about the subscriber's behavior on your website to your PushPushGo account. Thanks to this, we know what subpages they visited and what actions they performed.

PushPushGo offers several strategies for sending beacons to the application. Its choice depends on how your website is built.

<figure><img src="/files/hwPC6UckNbLHwifEaCoX" alt=""><figcaption></figcaption></figure>

**Default**: for pages that reload when an element is clicked

**Hash**: for older SPA pages (Single Page Applications) whose URLs contain "#", e.g. / # / profile /,

**History**: modern SPA pages running on the History API - page reload is not visible as in the default strategy, and there is no "#" sign in the URL

**Visibility change**: detection of an action indicating exiting the page, such as changing the tab, minimizing the browser window. Intended for pages on which, after clicking on a given element, a new tab opens in the browser.

\
All selectors defined on project contain concrete instructions on gathering data from the website and processing it. This is a single piece of information for a beacon.

Each transition on a page, like reloading it, leaving it, or moving to a new subpage, results in sending a beacon with data included in a selector for automation scenario purposes.


# Security SRI / CSP

How to self-host or use SRI / CSP with our scripts

In integrating our scripts into your website, you can choose between two main types of JavaScript scripts entrypoints and two Service Worker deployment strategies. This document explains their differences, advantages, drawbacks, and how to implement a secure setup using CSP and SRI.

***

### 📦 Script Types Comparison

| Script Type          | Size                                         | Dynamic Loading                            | CSP Compatibility       | SRI (Integrity) Support            | Self-hostable |
| -------------------- | -------------------------------------------- | ------------------------------------------ | ----------------------- | ---------------------------------- | ------------- |
| **Chunked**          | \~14 KB + \~140 KB of dynamic loaded modules | ✅ Loads from `/scripts/{version}/ppg-*.js` | ❌ Harder (many sources) | ❌ Not supported for dynamic chunks | ❌ No          |
| **All-in-One (AIO)** | \~140 KB                                     | ❌ No dynamic loading                       | ✅ Simple                | ✅ Fully supported                  | ✅ Yes         |

***

#### ✅ All-in-One (AIO)

**Advantages:**

* Simpler CSP (`script-src` with hash or `'self'`)
* Full SRI support (`integrity` attribute)
* Can be self-hosted (e.g., from your CDN)&#x20;
* Single HTTP request

**Disadvantages:**

* Larger file (\~140 KB)
* Slower perceived performance (everything loads upfront)

**Example with SRI:**

```html
<script
  charset="UTF-8"
  src="https://s-eu-1.pushpushgo.com/js/{projectId}/aio.js"
  integrity="sha384-<YOUR_HASH>"
  crossorigin="anonymous"
  async="async">
</script>
```

***

#### 🚀 Chunked Scripts (Dynamic)

**Advantages:**

* Smaller entrypoint (\~14 KB)
* Dynamic module loading as needed
* Better time-to-interactive (TTI)

**Disadvantages:**

* CSP setup is harder due to multiple dynamic sources
* No SRI support for dynamically loaded scripts
* Cannot self-host dependent scripts

**Example:**

```html
<script
  charset="UTF-8"
  src="https://s-eu-1.pushpushgo.com/js/{projectId}.js"
  async="async">
</script>
```

***

### 🧩 Service Worker Strategies

PushPushGo integration also requires a Service Worker. You have two main options:

| Approach          | Uses `importScripts` | CSP-compatible (`worker-src 'self'`) | SRI Support | Self-hostable |
| ----------------- | -------------------- | ------------------------------------ | ----------- | ------------- |
| **ImportScripts** | ✅ Yes                | ❌ No                                 | ❌ No        | ❌ No          |
| **Downloaded**    | ❌ No                 | ✅ Yes                                | ✅ (N/A)     | ✅ Yes         |

***

#### ✅ Recommended for better security: Downloaded Worker (`sw.js`)

**Benefits:**

* Allows full control over CSP (`worker-src 'self'`)
* Self-hostable and auditable

**How to fetch:**

```bash
wget https://s-eu-1.pushpushgo.com/{projectId}/worker.js -O sw.js
```

**HTML CSP Example:**

```html
<meta http-equiv="Content-Security-Policy" content="
  script-src 'self' 'sha384-<HASH>';
  worker-src 'self';
">
```

***

### ❄️ Freeze Mode Explained

PushPushGo offers a feature called **Freeze**. When enabled:

> The project configuration is locked. Any future changes made in the dashboard (e.g., selectors, feature toggles, popup forms) **will not propagate** to production environments.

This is especially useful when you:

* **Host AIO scripts or workers from our CDN and want to control, audit our "changes"**
* Want **stable script versions** without unexpected changes
* Need to ensure **CSP and SRI hashes remain valid**

**How to enable Freeze:**

* Go to: `Project > Settings > Integration > Web push integration`
* Enable the `Freeze` option
* Wait 2–3 minutes for CDN cache to sync

***

### ✅ Recommended for secure setup (All-in-One)

* Use `aio.js`
* Calculate SHA-384 hash (update {projectId} before execute):

```bash
curl -s https://s-eu-1.pushpushgo.com/js/{projectId}/aio.js | openssl dgst -sha384 -binary | openssl base64
```

* Update `<script>` tag with SRI
* Download and host `sw.js` locally

**Final CSP example:**

```html
<meta http-equiv="Content-Security-Policy" content="
  script-src 'self' https://s-eu-1.pushpushgo.com/js/{projectId}/aio.js 'sha384-<HASH>';
  worker-src 'self';
">
```

***

### 🔁 Update Checklist (AIO mode)

1. Fetch new version of `aio.js`
2. Recalculate SHA-384 SRI hash
3. Update `script` tag in HTML
4. Update CSP meta tag with new `'sha384-...'`
5. Update local `sw.js`

Stay secure! if you have any questions please contact with our customer support


# SDK Client

Our scripts expose SDK Client via \`ppg.client\` variable

PushPushGo Scripts expose a powerful `SDK Client` that allows you to customize the behavior and flow of notifications on your website. This guide will walk you through setup, registration, beacon usage, and subscription management using the SDK client.

***

### Overview

The `ppg.client` object becomes available when the SDK Client is enabled and properly integrated. It provides functionality to:

* **Register and unregister subscriptions**
* **Send custom data using beacons**

This allows for advanced, programmatic control over how you interact with subscribers and track user behavior or actions.

***

### Setup

1. **Integrate PushPushGo scripts** into your website.
2. Go to your **PushPushGo Project Settings**.
3. Toggle **"SDK Client"** to the **enabled** state.
4. Navigate to your website and open the browser console.
5. You should now see the `ppg.client` object available globally:

```js
console.log(ppg.client);
```

***

### Basic Usage

#### Registering a Subscription

Use the `register()` method to create or retrieve a current subscription:

```js
const subscriber = await ppg.client.register();

if (!subscriber) {
  console.log('No permission');
  return;
}

console.log('Permission granted');
console.log('Subscriber ID:', subscriber.id);
```

***

### Working with Beacons

The SDK client allows you to send custom data through **beacons**—small, structured payloads that track events or attributes.

#### Using the Beacon Builder

You can send a beacon using a fluent builder interface:

```js
await subscriber.send((beacon) =>
  beacon
    .appendLabel("test")
    .appendLabel("test2", "my_label", "append", 1234)
    .removeLabel("test", "default")
    .setCustomId("123")
    .setField("aaa", "bbb")
);
```

#### Using a Beacon Object Directly

Alternatively, you can build a beacon manually and send it:

```js
const beacon = subscriber.beacon();

await beacon
  .appendLabel("test")
  .appendLabel("test2", "my_label", "append", 1234)
  .removeLabel("test", "default")
  .setCustomId("123")
  .setField("aaa", "bbb")
  .send();
```

***

### Unsubscribing a Subscriber

To remove a subscriber from your notification list:

```js
await subscriber.unsubscribe();
```

***

### Summary

With PushPushGo's SDK Client, you gain fine-grained control over your web push notification subscriptions and event tracking. Use it to:

* Seamlessly manage subscription lifecycles
* Attach meaningful labels and data to subscriber actions
* Integrate custom tracking and analytics via beacons

For more information, consult your project settings or contact PushPushGo support.


# Legacy SDK (deprecated)

Old SDK docs

PushPushGo SDK is a software development kit that allows you to integrate web push without our integration script, but with customization possibilities.

### Setup

1. Place PushPushGo service worker with your project Id in sw\.js file on the website server.

{% code title="sw\.js" %}

```javascript
importScripts('https://cdn.pushpushgo.com/$projectId/worker.js');
```

{% endcode %}

2. Copy SDK script and place it in the website source code. Integration script has to be placed in the section of website's DOM structure.

{% code title="index.html" %}

```javascript
<head>
    <script src="https://cdn.pushpushgo.com/scripts/sdk.js"></script>
</head>
```

{% endcode %}

3. Initialize SDK client.

```javascript
const config = {
  projectId: $projectId,
  vapidPublicKey: $vapidPublicKey,
  isHTTPS: $isHTTPS,
  endpoint: 'https://api.pushpushgo.com',
  swPath?: $serviceWorkerPath,
  websitePushId?: $websitePushId,
};

const client = new ppg.sdk.Client(config);
```

| parameter        | type      | description                                                           |
| ---------------- | --------- | --------------------------------------------------------------------- |
| `projectId`      | `string`  | required                                                              |
| `vapidPublicKey` | `string`  | required                                                              |
| `isHTTPS`        | `boolean` | required, whetver your website address has `http` or `https` protocol |
| `endpoint`       | `string`  | required, value: `https://api.pushpushgo.com`                         |
| `websitePushId`  | `string`  | optional, for Safari < 16 integration                                 |
| `swPath`         | `string`  | optional, path to `sw.js` file when other than root                   |

### Push notifications

#### `isPushSupport(): Promise<void>`

Check if the browser supports web push notifications.

#### `checkPermission(): Promise<boolean>`

Check for native permission.

### Subscription

#### `register(options?: ISubscribeOptions): Promise<string>`

Register new subscriber - show popup dialog or native permission window

`returns` subscriberId

| parameter | type                   | description |
| --------- | ---------------------- | ----------- |
| `fields`  | `{ customId?: string}` | optional    |
| `tags`    | `string[]`             | optional    |

#### `isSubscribed(): Promise<boolean>`

Check if subscriber is registered

#### `getId(): Promise<string>`

`returns` subscriberId

#### `unsubscribe(): Promise<void>`

Unsubscribe existing subscriber at database

### Custom Id

#### `setCustomId(customId: string | number): Promise<void>`

Sets customId in cloned store

#### `getCustomId(): Promise<string>`

`returns` subscriber's customId

### Labels

#### `appendTags(tags: string[]): Promise<string[]>`

Append tags to store. For tag with labels support use `labelName:tagName` syntax.

| parameter | type       | description |
| --------- | ---------- | ----------- |
| `tags`    | `string[]` |             |

#### `getTags(): Promise<string[]>`

`returns` current subscriber's tags

#### `removeTags(tags: string[]): Promise<string[]>`

Remove tag(s) by label from store For labels support please use `'labelName:tagName'` syntax

#### `getTagsToRemove(): Promise<string[]>`

`returns` subscriber's tags to remove

### Session data

#### `setSelector(selectorName: string, value: string | number | null | boolean): Promise<void>`

Set selector value - field must be declared in application first

#### `clearState(): void`

Clear state, reset values

### Beacons

#### `send(immediately?: boolean): Promise<boolean>`

Set beacon to send on event before unload


# Examples

With the SDK client configured, except from basic subscription to web push notifications, you can use it to create your own component for subscribing to web push notifications, segment your subscribers with tags, link them with your CRM database by setting custom id, or send data for automation purposes.

### Custom subscribe button

1. Initialize SDK client
2. Use it to add web push registry functionality to button elements

{% tabs %}
{% tab title="subscribe.js" %}

```javascript
let client;

function getClient() {
  if (!client) {
    const config = {
      projectId: $projectId,
      isHTTPS: $isHTTPS,
      vapidPublicKey: $vapidPublicKey,
      endpoint: 'https://api.pushpushgo.com',
    };

    client = new ppg.sdk.Client(config);
  }
  return client;
}

function subscribeButtonClickedHandler(event) {
  event.preventDefault();
  client
    .register()
    .then(subscriberId => {
      setState(`user subscribed with id: ${subscriberId}`, false)
    });
}

function unsubscribeButtonClickedHandler(event) {
  event.preventDefault();
  client
    .unsubscribe()
    .then(() => {
      setState('user unsubscribed', true)
    });
}

function setState(status, canSubscribe) {
  const li = document.createElement('li');
  li.innerText = status;
  
  document.querySelector('#state').appendChild(li);
  document.querySelector('#unsubscribe').disabled = canSubscribe;
  document.querySelector('#subscribe').disabled = !canSubscribe;
}
```

{% endtab %}

{% tab title="index.html" %}

```javascript
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Subscribe button demo</title>
    <script src="https://cdn.pushpushgo.com/scripts/sdk.js"></script>
    <script type="application/javascript" src="subscribe.js"></script>
</head>
<body>
  <ul id="state">
      <li>checking push notifications state...</li>
  </ul>
  <button id="subscribe" disabled="disabled">click to subscribe</button>
  <button id="unsubscribe" disabled="disabled">click to unsubscribe</button>
</body>
<script>
  window.addEventListener('load', function() {
    const unsubscribeButton = document.querySelector('#unsubscribe');
    const subscribeButton = document.querySelector('#subscribe');

    subscribeButton.addEventListener('click', subscribeButtonClickedHandler);
    unsubscribeButton.addEventListener('click', unsubscribeButtonClickedHandler);

    getClient()
      .isPushSupport()
      .then(() => client.isSubscribed())
      .then(() => client.getId())
      .then(subscriberId => {
        setState('push notifications are supported');
        if (!subscriberId) {
          setState('activate subscribe button', true);
        } else {
          setState('user already subscribed with id: ' + subscriberId, false);
        }
      })
      .catch((err) => {
        setState('ops, sth went wrong, check console')
        console.log(err)
        setState('push notifications are not supported')
      });

  });
</script>
</html>
```

{% endtab %}

{% tab title="sw\.js" %}

```javascript
importScripts('https://cdn.pushpushgo.com/$projectId/worker.js');
```

{% endtab %}
{% endtabs %}

3\. To test if the subscription was successful, you can send a transactional web push notification via API

* `subscriberId` - from demo
* `x-token` - generate in the application [access keys section](https://app.pushpushgo.com/user/access-manager/keys)

```bash
curl --request POST \
  --url https://api.pushpushgo.com/project/$projectId/send/push \
  --header 'accept: application/json' \
  --header 'x-token: $x-token \
  --header 'content-type: application/json' \
  -d '{"to": $subscriberId, "message": {"title": "sdk example title", "body": "test sdk subscription example", "icon": "https://via.placeholder.com/150/150", "redirectLink": "https://www.google.com/"}}'
```

### Set Custom ID

You can link web push `subscriberId` with your own identifier by setting the `customId` with [`client.setCustomId()`](/web-push/sdk/legacy-sdk-deprecated/javascript-client#setcustomid-customid-string-or-number-promise-less-than-void-greater-than)

{% tabs %}
{% tab title="subscribe.js" %}

```bash
let client;

function getClient() {
  if (!client) {
    const config = {
      projectId: $projectId,
      isHTTPS: $isHTTPS,
      vapidPublicKey: $vapidPublicKey,
      endpoint: 'https://api.pushpushgo.com',
    };

    client = new ppg.sdk.Client(config);
  }
  return client;
}

function subscribe() {
  getClient()
    .isPushSupport()
    .then(() => client.isSubscribed())
    .then(isSubscribed => {
      if (!isSubscribed) {
        return client.register();
      } else {
        return client.getId();
      }
    })
    .catch(() => console.log('push is not supported'));
}

function setState(status) {
  const li = document.createElement('li');
  li.innerText = status;

  document.querySelector('#state').appendChild(li);
}
```

{% endtab %}

{% tab title="index.html" %}

```bash
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Set customId demo</title>
    <script src="https://cdn.pushpushgo.com/scripts/sdk.js"></script>
    <script type="application/javascript" src="subscribe.js"></script>
</head>
<body>
  <div id="crmId">SomeIdentifier</div>
  
  <ul id="state">
      <li>checking push notifications state...</li>
  </ul>

</body>
<script>
  window.addEventListener('load', function() {
    const crmId = document.querySelector('#crmId').innerText;
      
    subscribe()
      .then(() => client
        .setCustomId(crmId)
        .then(() => setState('subscriber customId set to' + crmId))
        
      .catch((err) => {
        setState('ops, sth went wrong, check console')
        console.error(err)
      });
  });
</script>
</html>
```

{% endtab %}

{% tab title="sw\.js" %}

```javascript
importScripts('https://cdn.pushpushgo.com/$projectId/worker.js');
```

{% endtab %}
{% endtabs %}

To be notified when `customId` is set, you can integrate with a [Webhook](/integrations/webhooks) `subscriber:update`

### Add subscriber tags

To add tags to subscriber, use [`client.appendTags()`](/web-push/sdk/legacy-sdk-deprecated/javascript-client#appendtags-tags-string-promise-less-than-string-greater-than)

{% tabs %}
{% tab title="subscribe.js" %}

```javascript
let client;

function getClient() {
  if (!client) {
    const config = {
      projectId: $projectId,
      isHTTPS: $isHTTPS,
      vapidPublicKey: $vapidPublicKey,
      endpoint: 'https://api.pushpushgo.com',
    };

    client = new ppg.sdk.Client(config);
  }
  return client;
}

function subscribe() {
  getClient()
    .isPushSupport()
    .then(() => client.isSubscribed())
    .then(isSubscribed => {
      if (!isSubscribed) {
        return client.register();
      } else {
        return client.getId();
      }
    })
    .catch(() => console.log('push is not supported'));
}
```

{% endtab %}

{% tab title="index.html" %}

```javascript
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Add subscriber tags</title>
    <script src="https://cdn.pushpushgo.com/scripts/sdk.js"></script>
    <script type="application/javascript" src="subscribe.js"></script>
</head>
<body>
</body>
<script>
  window.addEventListener('load', function() {
    
    subscribe()
      .then(() => Promise.all([
        client.appendTags(['Demo tag', 'Other demo tag']),
        client.appendTags(['label:tag']),
      ]))
      .then(() => client.send());
  
  });
</script>
</html>
```

{% endtab %}

{% tab title="sw\.js" %}

```javascript
importScripts('https://cdn.pushpushgo.com/$projectId/worker.js');
```

{% endtab %}
{% endtabs %}

### Send automation data

When you have automation configured in the [app.pushpushgo,](https://app.pushpushgo.com/automation) you will need to feed it with data, by sending a beacon by [`client.send()`](/web-push/sdk/legacy-sdk-deprecated/javascript-client#send-immediately-boolean-promise-less-than-boolean-greater-than) . Assume you have a selector with a name `basket` defined in the application, and you need to set it's value for the automation. In addition lets operate on tags that might be used in automation conditions and set the Custom ID.

{% tabs %}
{% tab title="subscribe.js" %}

```javascript
let client;

function getClient() {
  if (!client) {
    const config = {
      projectId: $projectId,
      isHTTPS: $isHTTPS,
      vapidPublicKey: $vapidPublicKey,
      endpoint: 'https://api.pushpushgo.com',
    };

    client = new ppg.sdk.Client(config);
  }
  return client;
}

function subscribe() {
  getClient()
    .isPushSupport()
    .then(() => client.isSubscribed())
    .then(isSubscribed => {
      if (!isSubscribed) {
        return client.register();
      } else {
        return client.getId();
      }
    })
    .catch(() => console.log('push is not supported'));
}
```

{% endtab %}

{% tab title="index.html" %}

```javascript
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Set automation data</title>
    <script src="https://cdn.pushpushgo.com/scripts/sdk.js"></script>
    <script type="application/javascript" src="subscribe.js"></script>
</head>
<body>
</body>
<script>
  window.addEventListener('load', function() {
  
    subscribe()
      .then(() => Promise.all([
        client.setSelector('basket', 19),
        client.appendTags(['Some condition tag', 'Other demo tag']),
        client.addTagsToRemove(['label:tag']),
        client.setCustomId('SomeIdentifier')
      ]))
    .then(() => client.send());
    
  });
</script>
</html>
```

{% endtab %}

{% tab title="sw\.js" %}

```javascript
importScripts('https://cdn.pushpushgo.com/$projectId/worker.js');
```

{% endtab %}
{% endtabs %}


# JS Code

Integration code callbacks and hacks

### Add customId to your subscribers

Add the code below to your HTML DOM Tree

```html
<var id="ppg-custom-id" data-id="your id here"></var>
```

### Fetch subscriber ID after register

Our standard integration code allows to register callback for **syncId** event.

When subscribers "subscribe" you can receive ID without usage of our SDK

```html
<script>
window.ppg = window.ppg || {};
window.ppg.register = window.ppg.register || [];
window.ppg.register.push(['syncId', subscriberId => console.log("Your SubscriberID:", subscriberId)]);
</script>
```

### Switch for subscribe action instead of popup

It's possible to do that just add `<input>` with type checkbox and `id="ppg-switch"`.

```html
<input type="checkbox" id="ppg-switch" disabled="disabled"/>
```

{% hint style="info" %}
You can hide popup by setting "delay popup time" to 999999s
{% endhint %}

Example code of toggle usage with styles you can see at: <https://github.com/ppgco/examples/tree/master/sdk_toggle>


# Safari support

### Safari > 16.4

Safari supports iOS push notifications from the version 16.4, however it requires the implementation of manifest.json file. You can setup your manifest.json yourself or generate it via any online service like: [Manifest Generator](https://www.simicart.com/manifest-generator.html/).

Your manifest attributes should contain:

* **$schema** (required)
* **display `standalone` or `fullscreen`** (required)
* **icons** to reference icons of several sizes (recommended)
* **id** (optional)

Example manifest file:

```json
{
  "$schema": "https://json.schemastore.org/web-manifest-combined.json",
  "display": "standalone",
  "start_url": "/",
  "name": "PPG Demo",
  "icons": [
    {
      "src": "/images/ca.png",
      "sizes": "40x40",
      "type": "image/png"
    }
  ]
}
```

#### Implementation

1. Once you have your manifest, add `manifest.json` to your root path of website. It must be accessible via `https://example.com/manifest.json`.&#x20;
2. Place index.html file in `<head>` section reference to manifest:

<pre class="language-html"><code class="lang-html"><strong>&#x3C;link rel="manifest" href="/manifest.json"/>
</strong></code></pre>

#### Testing

The implementation will work only if the website is **pinned** to home screen in iOS Safari.

1. Navigate to your website
2. Tap  "share" button
3. Tap "Add to Home Screen" option

Run the app pinned to the home screen.&#x20;

If you have completed all steps correctly, the web push subscription prompt will appear.

{% hint style="warning" %}
All Safari browser versions requires user gesture (click on desktop, tap on mobile device)  to display subscription prompt.
{% endhint %}

#### Invite users to pin your website to iOS home screen

If you wish to promote this feature in iOS Safari, you can use any open-source solution or create your own prompt to engage users. An example of such an implementation can be found in this repository: <https://github.com/rajatsehgal/add-to-home-screen>.

### Safari < 16

For old Safari versions authorization takes place via certificates. In order to integrate your project with APNs, you will need to request a certificate in a p.12 file format from a Certificate Authority in your Certificate Assistant first. [Check instruction here](/web-push/safari-support/safari-certificate).


# Safari Certificate

Instruction how to generate Safari certificate.

{% hint style="warning" %}
Currently, this is a legacy method - new Safari browsers (since 16) support PushAPI and VAPID. Use this instruction only when you want to support old Safari browser versions.
{% endhint %}

Integration with Apple Push Notification Service allows you to send push notifications through Safari browser.

Authorization takes place via certificates. In order to integrate your project with APNS, you will need to request a certificate in a p.12 file format from a Certificate Authority in your Certificate Assistant first.

Integration content:

* certificate store - store containing a private key and a public key issued for a specific appBundleId,
* passphrase for a certificate - can be empty if the store is not secured with a password

### Create Certificate Signing Request

To generate Safari certificate you need to create **Certificate Signing Request** first.

For this purpose, launch the Keychain Access app.

<figure><img src="/files/OG6lMghQZIIrmPizYOB3" alt=""><figcaption></figcaption></figure>

Click on Keychain Access > Certificate Assistant > **Request a Certificate From a Certificate Authority**.

<figure><img src="/files/Ok67Yioai4In69FBHg4R" alt=""><figcaption></figcaption></figure>

The Assistant window will appear. Enter your e-mail address and name for your certificate. Then check Saved to disk option and click Continue.

<figure><img src="/files/tQafgJQvb7WHyGqg9MPF" alt=""><figcaption></figcaption></figure>

Save the Certificate Signing Request (CSR). **You will need it to generate a certificate**.

<figure><img src="/files/vI9qnjh8duaqzbte2SQI" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/zAnnxnU5TlEJMAGdAWJ4" alt=""><figcaption></figcaption></figure>

### Register Website Push ID for APNS

Log into your [Apple Account](https://developer.apple.com). Here you will need to create **Website Push ID** for your project. In order to do that, go to Certificates, Identifiers & Profiles section.

<figure><img src="/files/BTeEmfhHafNF1DL6a7VD" alt=""><figcaption></figcaption></figure>

Select Identifiers tab and click "+" icon to add a new ID.

<figure><img src="/files/wUjSCxWy9dxoOvzFqeWV" alt=""><figcaption></figcaption></figure>

Check Website Push IDs option and confirm your choice by clicking Continue.

<figure><img src="/files/LJc4bB1n9yE3aUBHXs54" alt=""><figcaption></figcaption></figure>

Type description for your project in the Description input. In the Indentifier input enter the url of your domain (where you want to display the sign-up form). Remember to enter the url the opposite way, e.g. web.com.porannakawka.testppg. This is known as the **Reverse Domain Style**.

<figure><img src="/files/5OV7XTIem7pUV07hIGN6" alt=""><figcaption></figcaption></figure>

Click Continue and check if everything is correct. If so, confirm with the Register button.

### Generate Web Push Certificate&#x20;

Go to Certificate tab in Certificates, Identifiers & Profiles section. You will see a list of certificates you have created here. Click "+" icon.

<figure><img src="/files/RZ4cxVh2LinLCewxEx55" alt=""><figcaption></figcaption></figure>

Scroll down to "Services" part, check Website Push ID Certificate option and click Continue.

<figure><img src="/files/YpJNd3DWE4NnDYq7VJIh" alt=""><figcaption></figcaption></figure>

Select the Website Push ID you have created earlier from the list and click Continue.

<figure><img src="/files/8AGY9XTOEcalUJsWZB67" alt=""><figcaption></figcaption></figure>

Now you have to click on the Choose File button and select the CSR (Certificate Signing Request) you have generated. Proceed with Continue button.

<figure><img src="/files/K81TJQi6AxG8qd3OnsAz" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/jabGzYnStSIEVu0mGZMN" alt=""><figcaption></figcaption></figure>

Download your certificate. **Now we need to install and export it**. :warning: Double-clicking on the downloaded certificate will install the certificate in the Keychain Access app.

The installed certificate will appear in Keychain Access (which you have used to create CSR). Right-click on the certificate and select Export "Website Push ID:...".

<figure><img src="/files/MJk0XQCW94EYCewu4v8M" alt=""><figcaption></figcaption></figure>

Save certificate using Personal Information Exchange (.p12) format.

<figure><img src="/files/Ky8YkLoaOxkZJyXZhfNC" alt=""><figcaption></figcaption></figure>

Enter password and remember it - you will need to password to integrate your project with APNS.

<figure><img src="/files/Hfm1erU6b7GLfq7H6DAd" alt=""><figcaption></figcaption></figure>

Certificate has been saved on your device. It is ready to upload in our app.

<figure><img src="/files/rqC89mw3KQwCU8rmSrEW" alt=""><figcaption><p>Got it! <span data-gb-custom-inline data-tag="emoji" data-code="1f44f">👏</span></p></figcaption></figure>

Go to the Settings > Integration >Web push integration section.

<figure><img src="/files/q9o7tt9By7zqfbvrZzIa" alt=""><figcaption></figcaption></figure>

The next step is to upload the certificate store in the p12 file format and enter its passphrase (if required).

<figure><img src="/files/aXf1M76QaK1gWZFvZ3wI" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/JQGZDJZSt554Wuy8DHXs" alt=""><figcaption></figcaption></figure>

:information\_source: [Here](https://app.pushpushgo.com/project/providers) you'll find an alert about the approaching certificate expiration. We will inform you 30 days before the date.


# FAQ

Frequently Asked Questions about Website Integration.

<details>

<summary>I already have another service worker. Can I integrate with PushPushGo?</summary>

Yes, but since there is only one service worker allowed per domain, you need to either:

* join both service workers together using importScript:

```javascript
importScripts('
https://cdn.pushpushgo.com/63c574dd030eb6beb6d2c097/worker.js
')
```

* or put them separately and point where the service worker from PushPushGo app is located (on your site) by providing its path and typing ‘/ppg\_scope’ in service worker scope in Settings > Integration > Web Push (Vapid) section:

  <figure><img src="/files/SzBxgfo8cAC5o9Uybv17" alt=""><figcaption></figcaption></figure>

</details>

<details>

<summary>Is it possible to integrate Progressive Web Application (PWA) with PushPushGo?</summary>

Yes, but since PWA will always have its own service worker and there is only one service worker allowed, you need to use one of the solutions from question above **"I already have another service worker. Can I integrate with PushPushGo?"**.

</details>

<details>

<summary>Is it possible to integrate my website via Google Tag Manager (GTM)?</summary>

Yes, you can integrate your website via GTM, but only basic integration will be possible, since you do not have access to the server root path.

Go to your Google Tag Manager and then:

1. Create a new tag. Select the “Custom html” type and paste the code from the Integration > Installation tab.
2. Open "Advanced settings" and enter "1" in "Tag firing priority".
3. Set the trigger to “DOM Ready”.

   <figure><img src="/files/1Q4hhujLUotBfaaLAuQc" alt=""><figcaption></figcaption></figure>
4. Remember to publish the changes.

</details>

<details>

<summary>I have changed the service worker name but integration is not working. Why?</summary>

If you want to change the service worker name, for example from ‘sw\.js’ to ‘service-worker.js’:

* save the service worker path in Settings > Integration > Web Push (Vapid) as ‘/service-worker.js’.

  <figure><img src="/files/BV7Di1Q2CH2ZgnxkSziQ" alt=""><figcaption></figcaption></figure>

</details>

<details>

<summary>I have changed the directory where sw.js file is located but integration is not working. Why?</summary>

If you want to change the directory where the sw\.js file is located (for example, to ‘static/sw\.js’):

* save the service worker path in Settings > Integration > Web Push (Vapid) as ‘/static/sw\.js’ and service worker scope as ‘/static/’.&#x20;

  <figure><img src="/files/JE0ExtvtjxWQvVH3Ixrn" alt=""><figcaption></figcaption></figure>

Remember - after a setting scope different than ‘/’ (global), eg. ‘/static’, our application will work only on subpages in that scope or below, so:

* <https://example.com/static> - <mark style="color:green;">code</mark> <mark style="color:green;"></mark><mark style="color:green;">**will**</mark> <mark style="color:green;"></mark><mark style="color:green;">work here</mark>
* <https://example.com/static/page1> - <mark style="color:green;">code</mark> <mark style="color:green;"></mark><mark style="color:green;">**will**</mark> <mark style="color:green;"></mark><mark style="color:green;">work here</mark>
* <https://example.com/> - <mark style="color:red;">code</mark> <mark style="color:red;"></mark><mark style="color:red;">**won't**</mark> <mark style="color:red;"></mark><mark style="color:red;">work here</mark>
* <https://example.com/cart> - <mark style="color:red;">code</mark> <mark style="color:red;"></mark><mark style="color:red;">**won't**</mark> <mark style="color:red;"></mark><mark style="color:red;">work here</mark>

If you still want our code to work globally in that case, you have to set the scope as default - ‘/’  and add the following response header: "Service-Worker-Allowed": "/" to subpage containing service worker.

</details>

<details>

<summary>I want to integrate one project for each subdirectory of my website. How should I do it?</summary>

You need to integrate each project by placing the integration script in the corresponding website subdirectory source code and service worker in the subdirectory folder of the server.

Then, change the service worker path & scope of every project in Settings > Integration > Web Push (Vapid) accordingly. For example, for ‘your-site.com/en’ change the service worker path to ‘/en/sw\.js’ and the service worker scope to ‘/en/’, and for ‘your-site.com/de’, change the service worker path to ‘/de/sw\.js’ and the service worker scope to ‘/de/’.

Sometimes when there is no possibility to add more than one worker, you can try importing subdomains’ service workers into the main service worker and write logic to use them conditionally.

</details>

<details>

<summary>How to unsubscribe from notifications?</summary>

#### **Changing browser settings** <a href="#karm1qs37kim" id="karm1qs37kim"></a>

Every sign-up for notifications appears in the browser settings. Instructions for disabling notifications vary among different browsers.

**Google Chrome**

Go to Browser settings > Privacy and security > Site settings > Notifications. You can also paste chrome://settings/content/notifications in your address bar. On the list, you can find all the pages on which you have agreed to receive notifications. If you want to unsubscribe from any of them, just choose Remove from the menu.

<img src="/files/fCVJPpBpIwRM5UR5xhG9" alt="" data-size="original">

**Firefox**

After entering Options> Privacy and Security, search for Permissions>Notifications.

On the list, search for the page from which you want to unsubscribe, and choose the Remove Webiste option.

<img src="/files/fSuJe2TXM4bkTulZTE1S" alt="" data-size="original">

</details>

<details>

<summary>I can't sign up for notifications</summary>

If you have properly integrated PushPushGo with your site but still don’t see the sign-up form, or if your data isn't visible in the panel as the new recipient even after allowing notifications, check whether any of these apply:

* You are using an incognito window

<img src="/files/b5O0nVBtKpoPLoAi30Q4" alt="" data-size="original">

* You are already signed up for notifications
* You have blocked notifications in the browser settings
* You have blocked notifications in the operating system settings

Sometimes, testing the sign-up form requires performing steps that are not typical for an avarage user. It’s a good idea to clear any settings that might affect the notifications before testing the sigh-up process.

</details>


# Overview

We distinguish three services that enable sending push notifications via mobile application: Apple Push Notification service (APNs), Huawei Message Service (HMS), and Firebase Cloud Messaging (FCM).&#x20;

To be able to use these services and send push notifications via mobile app, integration using our SDK is required.

SDK functionalities are:

* subscribe / unsubscribe for push notifications
* send event delivered / clicked
* send beacon

Documentation can be found here:

* iOS: <https://github.com/ppgco/ios-sdk>
* Android / HMS: <https://github.com/ppgco/android-sdk>
* Flutter: <https://github.com/ppgco/flutter-sdk>

{% hint style="info" %}
Mobile providers' view in our application will be available for projects with mobile features enabled.
{% endhint %}


# Google Android

Firebase Cloud Messaging

To be able to use PushPushGo functionalities in your Google Android application, you have to integrate it using our mobile SDK and provide credentials for your project from Firebase console.

Choose suitable SDK and implement it in your application following repository documentation:

* Android / HMS: <https://github.com/ppgco/android-sdk>
* Flutter: <https://github.com/ppgco/flutter-sdk>

Generate a private key in Firebase console and upload it in our application. Go to Integration page in PushPushGo application:

<figure><img src="/files/kIpMYJgOUuCKTADScXhE" alt=""><figcaption></figcaption></figure>

select Google Android (FCM) and upload private key file (.json).

<figure><img src="/files/RMtKOgVqYV66SyCbauub" alt=""><figcaption></figcaption></figure>

The flag will change from NOT INTEGRATED to INTEGRATED.&#x20;

{% hint style="info" %}
Mobile integration is available for projects with mobile features plan. Contact us at <support@pushpushgo.com> in order to adjust plan to your needs.
{% endhint %}


# Apple iOS

Apple Push Notification Service

Integration with Apple Push Notification Service allows you to send push notifications through the Apple iOS platform. In order to integrate your mobile app with PushPushGo, implement one of our mobile SDKs in your application:

* iOS: <https://github.com/ppgco/ios-sdk>
* Flutter: <https://github.com/ppgco/flutter-sdk>

To complete integration, register App ID on Apple Developer account, create APNs certificate (.p12 file) and upload it in the Integration section. Start from getting your certificate.

Create Certificate Signing Request

To generate Safari certificate you need to create **Certificate Signing Request** first. For this purpose launch the Keychain Access app.

<figure><img src="/files/OG6lMghQZIIrmPizYOB3" alt=""><figcaption></figcaption></figure>

Click on Keychain Access > Certificate Assistant > **Request a Certificate From a Certificate Authority**.

<figure><img src="/files/Ok67Yioai4In69FBHg4R" alt=""><figcaption></figcaption></figure>

The Assistant window will appear. Enter your e-mail address and name for your certificate. Then check Saved to disk option and click Continue.

<figure><img src="/files/tQafgJQvb7WHyGqg9MPF" alt=""><figcaption></figcaption></figure>

Save the Certificate Signing Request (CSR). **You will need it to generate a certificate**.

<figure><img src="/files/vI9qnjh8duaqzbte2SQI" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/zAnnxnU5TlEJMAGdAWJ4" alt=""><figcaption></figcaption></figure>

Register an App ID

Log into your [Apple Account](https://developer.apple.com) and go to Identifiers section.

<figure><img src="/files/7vLDiaEbZ0VHJYnWZuSA" alt=""><figcaption></figcaption></figure>

In Indentifiers click the add button (+) on the top left.

<figure><img src="/files/ncorZE7BAIZMC0082D5X" alt=""><figcaption></figcaption></figure>

Select App IDs from the list of options and click continue.

<figure><img src="/files/682hVtxRDBGeH0i8XK9w" alt=""><figcaption></figcaption></figure>

Select App type and click Continue.

<figure><img src="/files/rARWLyU7fY8l8p7oeikV" alt=""><figcaption></figcaption></figure>

Enter a name or description for the App ID in the Description field. Select Explicit App ID and enter the app’s bundle ID in the Bundle ID field. The explicit App ID you enter here should match the bundle ID you entered in the target’s Summary panel in Xcode. Select the corresponding checkboxes to enable the app capabilities you want to use and click 'Continue'.

<figure><img src="/files/ybyTw6nofnOgrZyY70a7" alt=""><figcaption></figcaption></figure>

Review the registration information and click Register.

<figure><img src="/files/vpIlju6E8MEzLUthei90" alt=""><figcaption></figcaption></figure>

### Create certificate&#x20;

Go to Certificate tab. You will see a list of certificates you have created here.

<figure><img src="/files/XvHmwKPZobYX4GOoWIHO" alt=""><figcaption></figcaption></figure>

In Certificates, click the add button (+) on the top left.

<figure><img src="/files/7gD9j1DvvfgIGaRUs2j9" alt=""><figcaption></figcaption></figure>

Scroll down to "Services", select **Apple Push Notification service SSL (Sandbox & Production)** option and click Continue.

<figure><img src="/files/kuLl9MDIBjxDlCmnUMSJ" alt=""><figcaption></figcaption></figure>

Select the App ID you have created earlier from the list and click Continue.

<figure><img src="/files/ZtFZYGq2P0cqOEhCM9f7" alt=""><figcaption></figcaption></figure>

Now you have to click on the Choose File button and select the CSR (Certificate Signing Request) you have generated. Proceed with Continue button.

<figure><img src="/files/K81TJQi6AxG8qd3OnsAz" alt=""><figcaption></figcaption></figure>

Download your certificate, then double click on the file to install it.

<figure><img src="/files/JiijyOQWSMiUxMIsAnHi" alt=""><figcaption></figcaption></figure>

The installed certificate will appear in Keychain Access (which you have used to create CSR). Right-click on the certificate and export the file.

<figure><img src="/files/MJk0XQCW94EYCewu4v8M" alt=""><figcaption></figcaption></figure>

Save certificate using Personal Information Exchange (.p12) format.

<figure><img src="/files/Ky8YkLoaOxkZJyXZhfNC" alt=""><figcaption></figcaption></figure>

Enter password and remember it - you will need the password to integrate your project with APNS.

<figure><img src="/files/Hfm1erU6b7GLfq7H6DAd" alt=""><figcaption></figcaption></figure>

After saving a certificate, go to [Providers view](https://app.pushpushgo.com/project/providers) (left-side navigation > [Providers view](https://app.pushpushgo.com/project/providers)) in the PushPushGo application, then scroll down to IOS Support.

Upload your certificate in a p.12 file format, type the passphrase with which you have secured the certificate, toggle 'Toggle production' (unless you want integration to work in development environment) and click Save.

Remember that your project can only have one appBundleId assigned - and it can only be changed via an IT ticket. By uploading new certificates you are only overwriting them, without changing other parameters, i.e. appBundleId. If another certificate containing appBundleId is sent - an error will be returned.

In case of uploading an expired certificate or if there are more certificates and keys in the store - an error will be returned.

Go to Integration section in PushPushGo application and upload your certificate.&#x20;

<figure><img src="/files/PYOxLF0V6dMUVs2FhSyY" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/1l5Fm8KswACNUAoFtH65" alt=""><figcaption></figcaption></figure>

The flag will change from NOT INTEGRATED to INTEGRATED.&#x20;


# Huawei Android

Huawei Message Service

To be able to use PushPushGo functionalities in your Huawei Android application, you have to integrate it using our mobile SDK and provide credentials for your project from AppGallery Connect.

Choose a suitable SDK and implement it in your application following repository documentation:

* Android / HMS: <https://github.com/ppgco/android-sdk>
* Flutter: <https://github.com/ppgco/flutter-sdk>

Go to Integration page and then select Huawei Android (HMS)

<figure><img src="/files/ml9a3jWDtgz7KLyzweaK" alt=""><figcaption></figcaption></figure>

Type your App ID, Client secret, Auth URL, and Push URL and click Save.&#x20;

<figure><img src="/files/hkHqCADhtcONdMf4tgA1" alt=""><figcaption></figcaption></figure>

The flag will change from NOT INTEGRATED to INTEGRATED.&#x20;

You can change your HMS integration at any time.


# Overview

Onsite notifications are targeted messages that appear directly on your website to engage visitors in real time. They can be used to share updates, promote offers, and guide users during their session

While onsite notifications and [**web push notifications**](/web-push/overview) may look similar at first glance, they serve different purposes and audiences. Onsite notifications are shown only to users actively browsing your website, allowing for highly contextual and personalized engagement. Web push notifications, on the other hand, are delivered to a user’s device even when they’re not on your site, making them ideal for re-engagement and timely alerts outside the browsing session.&#x20;

A key advantage of onsite notifications is that they **don’t require user subscription**. This means you can reach a much larger share of your website visitors compared to web push, which requires explicit opt-in. It makes onsites a powerful option for maximizing reach and driving immediate action.

You will find this feature in the main navigation bar:.

<figure><img src="/files/CcHtIIQAWok77ixJuVBZ" alt=""><figcaption></figcaption></figure>

If you don't have the onsite notifications feature enabled, please contact us: <support@pushpushgo.com>.&#x20;


# Onsite notifications


# Create onsite notification

To create an onsite notification, go to onsite notifications from the main navigation bar.

<figure><img src="/files/CcHtIIQAWok77ixJuVBZ" alt=""><figcaption></figcaption></figure>

You will land on [Onsite notifications list](/onsite-notifications-list).

<figure><img src="/files/Sy5yK9wsIbDaLtp2ZrDx" alt=""><figcaption></figcaption></figure>

Now, click on the **New onsite notification** button in the upper right corner.

<figure><img src="/files/cqYvY5ieEPq31RewEOe1" alt=""><figcaption></figcaption></figure>

As soon as the onsite notification creator opens, you can begin the configuration of your notification.

First, decide on the character of your message. If you want the notification to be strictly informational, you don't need to perform any additional actions. If you want it to redirect users to a different URL, use the toggle shown on the screen below.&#x20;

<figure><img src="/files/IUQ7m9qlw3MVHV7pHXFA" alt=""><figcaption></figcaption></figure>

If you choose the Redirect on click option, make sure to use UTMs in the URL, so you can track the results in your Google Analytics (or any other tracker you use).

Next, prepare the content. You will need:

* Icon (most likely your project logo)
* Title
* Content
* Placement (e.g. bottom right)

Optional onsite elements:

* Image
* Actions
* Add overlay

<figure><img src="/files/C3Q1XaGnKBaVQ0I4rCCu" alt="" width="563"><figcaption></figcaption></figure>

Now, choose your audience. Onsite notifications can be displayed to all visitors after entering the website or to those who meet specific conditions.&#x20;

<figure><img src="/files/79b0JydPX0TEjmrRO0ug" alt="" width="375"><figcaption></figcaption></figure>

<figure><img src="/files/HtyBkgSlilwNXl4GkIyA" alt="" width="375"><figcaption></figcaption></figure>

Available data for setting up conditions:

* Referrer URL
* Visited URLs
* Number of visited URLs
* Language
* Current URL
* Is subscribed
* Session duration (s)
* Page visit time (s)
* Platform type&#x20;

The last step is to choose the display strategy:

<figure><img src="/files/em91gHmLa9TOFpH5ekxV" alt="" width="375"><figcaption></figcaption></figure>

To see all options above, you must also have the [Inbox](/onsite-notifications-1/inbox) feature included in your plan.&#x20;

The display duration specifies how long notifications will be actively visible on the user's device screen until manually dismissed or clicked on.&#x20;

You can also decide if you want to limit the visibility to particular dates.&#x20;

When you are done with the configuration, hit the "Create notification" button.&#x20;

Now, you can decide if you only want to create a draft or publish and activate the campaign:

<figure><img src="/files/ICrXVcrsBHKJBtViOisY" alt="" width="563"><figcaption></figcaption></figure>


# Edit onsite notification

You can edit your onsite notification by hitting the three dots on the selected message on the onsite list.

<figure><img src="/files/R6dQJlhkQArwrkY1XU5T" alt="" width="375"><figcaption></figcaption></figure>

After you finish tweaking the content or settings of the message, hit the "Save changes" button.


# Onsite notification report

Access the onsite notification report from the onsite list by clicking on the three dots.

<figure><img src="/files/P0DIGIjSadxfuu6ZNcCo" alt="" width="375"><figcaption></figcaption></figure>

Now, you can see the notification status, content, and settings.

<figure><img src="/files/neukwvX7A9toStgMwOES" alt=""><figcaption></figcaption></figure>

Below, you will find the notification's statistics.

<figure><img src="/files/9MJRoBcrnFH7aWPtQiuy" alt=""><figcaption></figcaption></figure>


# Inbox

If you want to expand the reach of your onsite notifications, you can also configure them to show up in the Inbox under the [bell widget](/web-push/integration-script/bell-widget).&#x20;

<figure><img src="/files/W8i8P1ixMAXaHsYHL4PG" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/eprhaTrg4Cei4rBReLLJ" alt="" width="302"><figcaption></figcaption></figure>

Talk to our <support@pushpushgo.com> to add this feature to your plan!


# Onsite notifications list

The Onsite notifications list allows you to view all your onsite messages.

<figure><img src="/files/07ZNByhGwCfbzejXf70Z" alt=""><figcaption></figcaption></figure>

You can search onsite notifications using their Title and sort them by Newest and Oldest.&#x20;

<figure><img src="/files/PlIcjXI9QwZSBwDmkmqb" alt=""><figcaption></figcaption></figure>

The information about your onsite notifications that you can review on the list:

* Icon
* Title
* Start date (if used)
* End date (if used)
* Status (active or not active)

You can also go to [Report](/onsite-notifications-1/onsite-notification-report), Edit, Enable, Disable, and Delete an onsite notification.&#x20;

<figure><img src="/files/xnNz816NzxlB358G21LZ" alt="" width="338"><figcaption></figcaption></figure>


# Overview

Set up and manage your WhatsApp channels with PushPushGo.

* Add the most popular communications app to your communication strategy within the same platform.&#x20;
* Turn your web push into a WhatsApp message and grow your outreach to app users.&#x20;
* Create multiple channels for your project.&#x20;
* Invite users to subscribe to your WhatsApp channels using your web push and onsite channels.&#x20;

<figure><img src="/files/4eCgNyVTzkBRB7zhVmru" alt="" width="216"><figcaption></figcaption></figure>

<figure><img src="/files/rtBbJ7dpqy6cQ4lcgGeW" alt="" width="216"><figcaption></figcaption></figure>

Let us manage the integration, including adding a phone number and establishing the Whapi connection.

Request Whatsapp to be added to your account. Contact your account manager or <support@pushpushgo.com>.&#x20;

<br>


# Whatsapp channel


# Create a channel

To create a channel, go to WhatsApp option and click on New WhatsApp channel.

<figure><img src="/files/kymcXkypwm126vfGOcFA" alt=""><figcaption></figcaption></figure>

Fill in your channel details.&#x20;

<figure><img src="/files/t5EgXu3mxofB6Sa5umry" alt=""><figcaption></figcaption></figure>

These details will be visible to your audience.&#x20;

You can also assign a channel to a segment.&#x20;

* Segments are linked to your *web push notification channel* (If you don't use web push, this option will be not available to you).&#x20;
* Assigning a WhatsApp channel to a segment *does not mean* that your web push audience will be automatically subscribed to the channel you are creating. You must invite them to opt in separately.
* If you create a web push campaign targeting a segment assigned to the WhatsApp channel, and choose to convert it into a WhatsApp message, the correct channel will be selected automatically.

<figure><img src="/files/TryMbgOUHtQPfVh1Pu8D" alt=""><figcaption></figcaption></figure>

After you click “Create channel,” a message will appear indicating that the channel is pending activation. It usually takes a few seconds to receive confirmation that the channel is ready.

<figure><img src="/files/b4QodVlVhpvHqt8le2OS" alt=""><figcaption></figcaption></figure>

Now, you can start inviting users to your WhatsApp channel using a link or QR code provided.


# Subscribers

Number of subscribers to a channel will be displayed on the channels list.

<figure><img src="/files/Qpvr7Ivw6n4qUa3Cprng" alt=""><figcaption></figcaption></figure>

You can also check that number dirrectly in your channel details in WhatsApp.&#x20;

<figure><img src="/files/gqjMRwlV0J7ASLSybEHK" alt="" width="214"><figcaption></figcaption></figure>

**Your subscribers are anonymous.**

* WhatsApp channels keep the data about senders and recipients hidden.&#x20;
* Phone numbers of senders and recipients are kept anonymous.

There is no option to match your WhatsApp subscribers with web push subscribers or a traffic on your website.

**Take advantage of the PushPushGo toolbox.**\
Turn your website visitors and web push subscribers into WhatsApp channel followers.\
Grow your WhatsApp subscriber base by:

* linking a subject-specific WhatsApp channel below an article on your website
* promoting a channel QR code with a banner on your webiste
* sending a web push to all subscribers with a link to the channel
* placing an onsite notification on your website with a link to the channel


# Create a WhatsApp message

To send a WhatsApp message you can:

* create a WhatsApp message from scratch
* turn a web push into a WhatsApp message

#### Creating a new WhatsApp message

Go to WhatsApp messages and click on New WhatsApp message.

<figure><img src="/files/T6IimBxeTaRukw5KgrZ2" alt=""><figcaption></figcaption></figure>

1. Fill in message details.

Body (required): Enter the main content of your WhatsApp message. You can include URL links.
\
To include additional elements to your message, toggle the "Add link preview" switch.
\
If you'd like to add a title and description for the link preview, fill in the corresponding fields.
\
You can also include media in the preview.

<figure><img src="/files/CGYkUq8ieU9ImEHEYc4M" alt=""><figcaption></figcaption></figure>

You can review how the message will appear on Android and iOS.

<figure><img src="/files/aqprecfoGt2Co4jlnm65" alt=""><figcaption></figcaption></figure>

The link you provide for the **Body** field will be converted into a short version, with the domain ppgwh.com.&#x20;

2. **Select your audience.**&#x20;

If you have more than one Whatsapp channel operating through the PushPushGo app, choose which ones will receive your message.&#x20;

3. **Schedule sending time**&#x20;

Send the message immediately or schedule a time for deployment. &#x20;

<figure><img src="/files/WklQhz2kUMccFQnYXSXQ" alt=""><figcaption></figcaption></figure>

**Important: A** WhatsApp message cannot be stopped once you send it.

#### Converting a web push into a WhatsApp message

When preparing a web push, you can choose to send it to your WhatsApp channel as well.

<figure><img src="/files/fCrkj9G3t7wVPjKeuPSh" alt=""><figcaption></figcaption></figure>

If you do so, you will get an additional preview option.

<figure><img src="/files/DYZi8dB26216Fevl70qd" alt=""><figcaption></figcaption></figure>

Here is an example of how web push converted into a WhatsApp message looks.&#x20;

web push&#x20;

<figure><img src="/files/KCR2Ycwrdt7dRFwdXlb6" alt=""><figcaption></figcaption></figure>

WhatsApp&#x20;

<figure><img src="/files/QtecRlTdNLquzuNpbzWQ" alt=""><figcaption></figcaption></figure>

You can choose whether or not to include a description in your WhatsApp message.

<figure><img src="/files/ulzQ2aItxBoN0hO8fj8y" alt=""><figcaption></figcaption></figure>

If you opt in for the description, the message section of your web push will be included in the preview of your WhatsApp message.

<figure><img src="/files/EnyLVyWxkGtmpU96JK0X" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/e4WUSTE8WcZwlBpPf5e9" alt=""><figcaption></figcaption></figure>


# Overview

**Pop-ups** are interactive on-screen elements that appear on top of a webpage's main content. They are typically used to capture attention, deliver messages, or encourage specific actions from users. They are highly versatile tools that can be triggered based on user behavior, time on site, scroll position, or exit intent.

Use cases:

* promoting newsletter subscriptions
* highlighting featured articles or content
* offering premium memberships or gated content
* announcing sales, discounts, or limited-time offers
* reducing cart abandonment with exit-intent offers
* upselling or cross-selling products

All types of websites, from news portals and blogs to e-commerce retailers, as well as travel, finance, and other online services, can benefit from them.&#x20;

Pop-ups can be customized in appearance, timing, and targeting to ensure they feel relevant and non-intrusive to the user experience. When used thoughtfully, they are a powerful tool to boost conversions, grow your audience, and increase user interaction.

<figure><img src="/files/6Fv9fq5Pm69jqCb262Hr" alt=""><figcaption></figcaption></figure>

If you do not have this feature enabled and you would like to test it, please contact us on <support@pushpushgo.com>.


# Pop-ups


# Create a pop-up

To create a pop-up, go to Pop-ups options from the main navigation bar.

<figure><img src="/files/b73JDtJLTYgHQBwNPN6Q" alt=""><figcaption></figcaption></figure>

You will land on [pop-up list](/pop-up-list).

<figure><img src="/files/gUpLtZDLvGsnBlI3PNGH" alt=""><figcaption></figcaption></figure>

Now, click on the **New pop-up** button in the upper right corner.

<figure><img src="/files/lIXsVS9CO1vxkygtc7hp" alt=""><figcaption></figcaption></figure>

You will see eight pop-up templates that you can use.

<figure><img src="/files/R20yrBB24mGvS17PxFEO" alt=""><figcaption></figcaption></figure>

Once you select a template, you can change the image, content, and buttons, but not the general shape or other elements inside the pop-up layout. As we develop this feature, we will add the option to create a layout from scratch, giving users more flexibility.&#x20;

Available templates reflect use cases that our web push customers reported as most needed. For example, you can use pop-ups to request unblocking web push notifications in Google Chrome, or adding your website to Home Screen (iOS). Others were designed for websites with purchase processes; to boost your conversions, save abandoned baskets, and require other actions from your users, like asking for reviews.&#x20;

After selecting the pop-up template for your use case, click on it to tweak its style and content. Start from naming your pop-up.

<figure><img src="/files/YnM1EhkIw0hSP3NGjirw" alt=""><figcaption></figcaption></figure>

In this example, we can edit:

* layout (precise placement on your website)
* style (color, corner radius, border, font, close icon button, icon color and size, animation, drop shadow, overlay)
* title&#x20;
* description
* image (you can hide it on mobile devices)
* action (action type, including custom js)
* action&#x20;

Choose your audience.

<figure><img src="/files/buNOgX8zfqIvQonqRwUM" alt=""><figcaption></figcaption></figure>

Now, you can select the trigger, display, and how many times the pop-up should appear to the same user.&#x20;

<figure><img src="/files/IKnnnFRxH2DCaY8IxxRQ" alt=""><figcaption></figcaption></figure>

Once you are done, hit Create pop-up.

<figure><img src="/files/9c7cJetCrJeIVTj8km75" alt=""><figcaption></figcaption></figure>

The system will ask you to confirm whether the pop-up should be published immediately or only created.&#x20;

<figure><img src="/files/7Ol8mIMhDs9cvxUYpbe5" alt=""><figcaption></figcaption></figure>


# Edit pop-up

To edit an existing pop-up, access the pop-ups list by clicking on Pop-ups on the main navigation. Now, choose the pop-up to edit and click on three dots.

<figure><img src="/files/jMs7mMrmOG90vEvOOqcS" alt=""><figcaption></figcaption></figure>

You will see the drop-down list with an option to edit.

<figure><img src="/files/90WttHL4UilbFWZhvjzb" alt=""><figcaption></figcaption></figure>

You can tweak every setting that was available during the creation of the pop-up. After you are done, hit Save changes.&#x20;


# Pop-up report

In the Pop-up report you will find details and statistics of your pop-up.

<figure><img src="/files/Ghf3pBGWLmPca0FkjoPg" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/qNS1sd2eJmnrW1Of73wf" alt=""><figcaption></figcaption></figure>


# Pop-up list

On the pop-up list you will find all pop-ups that you have created.

<figure><img src="/files/b4BQOp19u7hWsAcaNxJa" alt=""><figcaption></figcaption></figure>

On the list, you can see each pop-up's name, trigger, and status. You can edit pop-ups and access additional options by clicking on the three dots.

You can search pop-ups by name, sort them by newest or oldest, change their status (enable/disable), or edit their content and settings.&#x20;

There is an option to create a new pop-up from here, by clicking on the New pop-up button in the upper right corner of the screen.&#x20;


# Overview

A **Follow-up campaign** is a type of web push campaign available in PushPushGo. It enhances communication with users by allowing you to send a **series of notifications** or **increase the reach** of a specific message.

Each Follow-up campaign consists of a **source campaign** and one or more **follow-ups** that are sent after the source campaign.

You can use a follow-up strategy in two main ways:

1. **Create a sequence of notifications** to maintain ongoing user engagement.
2. **Increase the reach of a campaign** by sending follow-ups to subscribers who did not receive the original message — for example, due to technical issues or temporary unavailability at the time of the initial send.

This feature helps ensure **broader message delivery** and supports **multi-step communication strategies** for more effective user engagement.


# Follow-up


# Create a source campaign

You can create a **Follow-up campaign** directly from the **Dashboard** by selecting **Follow-up campaign** from the drop-down menu.

<figure><img src="/files/dUtwhWTLMEeKgzFfYuZJ" alt=""><figcaption></figcaption></figure>

Once selected, you’ll be taken to the follow-up creator.&#x20;

**1. Name your campaign**

<div data-full-width="false"><figure><img src="/files/tSWYJVhHai8Ddm537e6J" alt=""><figcaption></figcaption></figure></div>

**2. Complete the campaign setup**

Because a follow-up is a type of web push campaign, the creator works exactly like the **Web Push Creator** you already know.\
Fill in all the required sections:

* **Message** – Define the content of your notification.
* **Audience** – Select the subscribers or segment you want to target.
* **Time** – Choose when your notification should be sent.

**3. Plan your source campaign**

Next, plan your **source campaign**.\
Keep in mind that you can send or schedule the first follow-up **only after the source campaign’s expiration date**.

**4. Review your campaign summary**

After clicking **Plan campaign**, you’ll be redirected to the **Summary Report** for the follow-up campaign you just created.\
To view your **source campaign report**, simply switch to the corresponding tab.

<figure><img src="/files/q9QkSETmyUkAKm0DWYYt" alt=""><figcaption></figcaption></figure>


# Create a follow-up

You can schedule **up to three follow-ups** within a single Follow-up campaign.

Each follow-up is possible because **PushPushGo** automatically collects specific system labels from every campaign sent within the same follow-up campaign:

* `sys.prev_campaign` – identifies users who were **sent** the campaign
* `sys.prev_delivered_campaign` – identifies users who **received** the campaign
* `sys.prev_clicked_campaign` – identifies users who **clicked** the campaign

These labels are later used to define **Audience conditions** for your follow-ups, allowing you to target users based on their engagement with previous messages.

When you’re ready to send a follow-up:

**1. Go to the Follow-up list in the Campaigns section.**

<figure><img src="/files/9GXvIOITT7AwkHnwv5PE" alt=""><figcaption></figcaption></figure>

**2. Find the campaign you want to follow up on.**

**3. Click the three dots (⋯) next to the campaign name and select Follow up.**

<figure><img src="/files/Z8izJUJMM7DKTabPKaGM" alt=""><figcaption></figcaption></figure>

**4. The app will ask if you want to copy the content of the source campaign.**

<figure><img src="/files/icO6EDJuPKKUvznb6vBB" alt="" width="375"><figcaption></figcaption></figure>

**5. Adjust the Content of the message if needed.**

**6. Choose the Audience and the strategy.**

<figure><img src="/files/VKYJnd4Qe9u0a5BNvZhz" alt=""><figcaption></figcaption></figure>

**7. Fill in the time section and plan your follow-up.**


# Follow-up report

The **Follow-up campaign report** is organised into tabs that help you analyze campaign performance and see each campaign details:

* **Summary report** – Provides an overview of the entire follow-up campaign, including key metrics such as delivery, clicks, and engagement rates.
* **Source campaign and follow-ups** – Displays detailed information for the **source campaign** and each **follow-up**, including the **message content (copy)** and the **audience** used in each campaign.

<figure><img src="/files/lsXck3aqEN6jhMEzKjg4" alt=""><figcaption></figcaption></figure>

The **Summary Report** provides an overview of all campaigns included in a follow-up campaign. It consists of the following sections:

* **General statistics** – Displays cumulative numbers from all campaigns within the follow-up Campaign.
* **Details** – Shows the campaign name, current status, and the status of the most recent campaign.
* **Results** – Presents a table with key statistics and engagement metrics for each campaign.
* **Reach and engagement** – Displays a chart illustrating fluctuations in engagement metrics (such as **CTR** and **DSP**) throughout the entire Follow-up campaign.

<figure><img src="/files/9M3CqitQxgS4LtmePmsD" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/wlkgpkbvpJvghKuff6qw" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/DwmqF7KjmNZnbUdia0gl" alt=""><figcaption></figcaption></figure>

Thanks to the **Results** and **Reach and engagement** sections, you can easily analyze how each campaign performed, compare their effectiveness, and gain valuable insights to improve your overall strategy.

**The source campaign and the follow-up** details can be found under these tabs.

<figure><img src="/files/KOxjrCEKUb5TGgAweAfR" alt=""><figcaption></figcaption></figure>


# Follow-up limits

* Each **Follow-up campaign** allows you to create **one source campaign** and up to **three follow-ups**.
* You have **12 days** from the moment the source campaign is sent to complete the entire follow-up sequence.
* If you plan to send all three follow-ups, we recommend spacing them **approximately three days apart** to ensure balanced timing and user engagement.

  A new campaign in the sequence can be **sent only after the previous campaign has expired**.


# Follow-up list

You can access the **Follow-up list** by opening the **Campaigns** section and switching to the **Follow-up** tab.

<figure><img src="/files/kZe6DJ9mdbHA8qvqtoux" alt=""><figcaption></figcaption></figure>

On this list, you’ll find all Follow-up campaigns that have been created in your project.

<figure><img src="/files/NBZDUy9qEr62qTMvf2Pe" alt=""><figcaption></figcaption></figure>

Each campaign has its name, status and last campaign status.&#x20;

<figure><img src="/files/jUhLtCZngwfCoRHumnMs" alt=""><figcaption></figcaption></figure>

From the **Follow-up list**, you can either **create a follow-up** for an existing campaign or **view its report**.\
The follow-up action is available **only when the campaign status is “In progress.”**


# Subscribers

A subscriber is a person who agreed to receive web push notifications from your website.

In the Subscribers view, you’ll find information on active subscribers. You can see their numbers, browse the detailed data, and check their current descriptions assigned by the automation processes or the system.

<figure><img src="/files/vK1IGKEboYNjfk6g1iRc" alt=""><figcaption></figcaption></figure>

This view allows you to [manually](/subscribers/labels/add-labels-manually) add [**labels**](/subscribers/labels) to a subscriber. Check all the data following their description and basic rules of label creation.

{% hint style="info" %}
Labels added manually are assigned only by rewriting. They affect segment counting.
{% endhint %}

You can also filter the subscribers’ list by [segment](/subscribers/segments). This allows you to see if a subscriber is assigned to one of the segments created for the project.&#x20;

<figure><img src="/files/0EzLpkd16Ngyc1Xt90oy" alt=""><figcaption></figcaption></figure>


# Activity status

Current status is an important part of information about individual subscribers. It determines if they can receive our notifications or not. We only distinguish two statuses: Subscribed and Unsubscribed.

Subscribed user is one to whom we can send a notification.

The Unsubscribed status means that user won't receive notifications for a variety of reasons:

* They unsubscribed using the browser settings
* They uninstalled the browser
* They uninstalled Service Worker in the browser (this happens while cleaning the browser settings).


# Subscriber details

If you want to see detailed information on a subscriber, click ![](/files/r9k34c7bAscNKM7QLbRs)\
This view provides you with details about the subscriber's current status, characteristics, and system labels. See it to better understand how this data can be used to create [**segments**](/subscribers/segments).&#x20;

Here's the information you'll see:

<figure><img src="/files/MtuKko6ssfW9jgbSiznH" alt=""><figcaption></figcaption></figure>

You can see:

* information on customid and provider
* a date of subscribing and current subscriber status
* information about their last session: when were they active, visited URLs and time spent on a site
* current labels
* last visited URLs&#x20;
* data collected with selectors from the [last session](broken://pages/RRLZlBGdf45fpK411yxG)&#x20;


# Labels

Labels are one of the primary elements allowing you to later define groups of subscribers by segments or send campaigns to specific labels.

Labels are easy to understand, implement (no-code), and manage.

Simply put, a label is a characteristic you can ascribe to a subscriber in your base.

There are two types of labels: user labels and [system](/subscribers/labels/system-labels) labels. The first kind can be added, modified, saved, and deleted at your convenience. The latter can only be added and modified by the system.&#x20;

Another advantage of the key:value labels is that they can be used for push [personalization.](/campaigns/push-campaign/create-campaign/content/personalization)

A label consists of:&#x20;

* Key - the system labels have a “sys.” prefix in their key names. You can name your keys in the user labels however you want (ex. last\_visit or cart\_value) and use stop marks in the name&#x20;
* Value - in the form of date, number, words, or true-false value&#x20;
* Time-to-live (TTL) - a time after which the label will expire on a given subscriber

{% hint style="info" %}
System labels contain information about a subscriber’s platform, language, region, and operating system. They are useful in defining Segments.
{% endhint %}

A label can be saved to a subscriber in one of the following ways:&#x20;

* append - simply put, it’s a set of values. For example a category label with the category-related values \[blouses, jackets, scarves]. When appending, we can add a “beanie” value to the set.&#x20;
* rewrite - a relation of key and a single value. It means that we can change the value of a last\_category label from last\_category: beanies to last\_category: blouses.

{% hint style="info" %}
The labels are not predefined: you can ascribe them to a subscriber according to your needs.

You don't have to configure them beforehand.

Well-defined labels in automation processes or selectors help you to define more accurate segments.
{% endhint %}

You can add labels to a subscriber in the [Subscribers ](/subscribers/subscribers)view, during the[ automation](/automation/labels) scenario edition, and in the [Selectors](/automation/selectors) view.


# System Labels

{% hint style="info" %}
Data on geolocation are collected according to priority: shared location, geo-ip.  Each time the geolocation data changes, subscriber labels are modified.&#x20;
{% endhint %}

{% hint style="info" %}
System labels can be used to build segments.
{% endhint %}

Examples of system labels:

&#x20;\- sys.platform: browser

&#x20;\- sys.provider: google\_vapid

&#x20;\- sys.geo\_country\_code: PL

&#x20;\- sys.geo\_city: Oswiecim

&#x20;\- sys.geo\_region: Lesser Poland

&#x20;\- sys.timezone: Europe/Warsaw

&#x20;\- sys.language: pl

&#x20;\- sys.browser: Chrome

&#x20;\- sys.os: Windows

&#x20;\- sys.device: desktop


# Add Labels Manually

Clicking ![](/files/ikL9aRylmCtAGN7xr3Dv)  on Subscribers list will open a new view:&#x20;

<figure><img src="/files/e4VbWWLqWgAgWHs0jcmL" alt=""><figcaption></figcaption></figure>

If you want to add a label to a subscriber, type in **key**, **value,** and **TTL** (optional).

If you want to unassign a label, click **X** on a selected item.&#x20;

When you click **'Add label'**, the label will be added to a subscriber. Repeat the steps to assign more.&#x20;

Click **'Save'** to save the changes.&#x20;


# Segments

<figure><img src="/files/RuSDl6OhzuYIMFwrJ0Yi" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
You can create up to 5 segments in each project.
{% endhint %}

Segments allow you to create conditions based on [Labels](/subscribers/labels). The latter determine if a subscriber belongs to a given segment.

Each segment has its properties:

&#x20;\- **name** - unique within a project

&#x20;\- **status** (draft, building, or ready) - every created segment is in the ‘building’ status and becomes ‘ready’ after it's calculated

&#x20;\- **audience** - a precise number of current subscribers in a segment

After defining a segment, the building process begins. It may take a while - we need to scan each subscriber in the base and match them with the segment conditions. When the process ends, the segment switches to ‘ready’. It displays the number of subscribers within it. You can send messages to them.

Every time you change or add labels to a subscriber, it causes changes in the segments. They are rebuilding in real-time, following new subscriber descriptions per labels.

Segments allow you to send a push to a selected group much faster than [other targeting options](/campaigns/push-campaign).

You can find segments defined for a project in the Segments view.:

<figure><img src="/files/Y00o7e4WePNYZ827pZxA" alt=""><figcaption></figcaption></figure>

You can search segments by name or sort them, either alphabetically or chronologically (by creation date). The view allows you to delete, copy, and edit segments. You can create a campaign for a given segment with a ‘ready’ status by clicking on a green button with an arrow sign.

<figure><img src="https://lh4.googleusercontent.com/0EkP-2EESEz2dqpRVtJLp_lOAxtXpoqUEfsTm33OdkOEVRUloXkZT35jei5Yz7ioagxFZh83WgnucAqdkB8lzZZ2tLCHU3Bygse_u7XC0EmiTFCFEopSIcSRxR1SeJj6mrzNvzCddb7tctL-CseSGghKNxsHVuvCl4FZoVu0EQp4hWyd2Fnv1ZgREw" alt=""><figcaption></figcaption></figure>

Deleting a segment won't be possible if it’s currently used in a planned campaign, a saved draft, or in a campaign that’s being sent. It prevents unnecessary complications and errors in campaigns.


# Create Segment

The Segment List  will be empty until you create the first segment. You can do it by clicking one of the two buttons:

<figure><img src="https://lh3.googleusercontent.com/iMtBAaTT1SFd3I0JqbAJKgiFYo2WGYVkXmktzXt_mnSqWHIDv6rGReAZrBnx1faDKoudTlZ0U9lZ_zNYA5y6nZ6xn7MRVIRfUwGzkU_zoEacuTTrUEjUkgc-iu44llKyDrcSTRjyVyVIAMhNbUVlum0lw54nprnWCi4CehPds80fQikHXUfkWn7Prg" alt=""><figcaption></figcaption></figure>

In the creator, you can declare conditions to extract subscribers.&#x20;

Below you can see a segment creation view:

<figure><img src="https://lh5.googleusercontent.com/_ItSe7_pK8GJg4oua2tgrXFcIAj2BZhwWxPYKqrYC4QHQVI-7nzx7gJgM1uE2ltpkNFeFvFgy5HOL5WePU-ho1JwZ_2h4mudvxRj-EDJEl1_9_nO8LFUzNXiw0UrX_Bs7ng7lh7uRyoR60-3rTckWmpT01nLGc-Gb2LVJdIXoKyu0l_CNPaRsisFqw" alt=""><figcaption></figcaption></figure>

The segment name will be filled in automatically with the date and hour of creation. You can change it and add details essential for the segment using up to 60 A-Z, a-z, 0-9, and - \_ : + . sings and space.

Below the name, you’ll find the core part of the creator: ascribing the conditions based on  [labels](/subscribers/labels).&#x20;

Just to recap: a single label has the “key value” form. Similarly, segments have a “Field” (Label Key), a matching operator (ex. “Equal”), and a specific “Label Value”. &#x20;

You can add new conditions in groups, using the 'AND' strategy (green field). Each new group will be preceded by the 'OR' strategy.&#x20;

<figure><img src="/files/0YB9PHcTKv3yXoguRENb" alt=""><figcaption></figcaption></figure>

{% hint style="warning" %}
Remember! A segment must consist of at least one condition.&#x20;
{% endhint %}

When you create conditions based on labels, you'll get a number of operators you can use. For example, 'equal' and 'not equal' will include subscribers who have (equal) or don't have (not equal) a specific label connected.&#x20;

<figure><img src="https://lh5.googleusercontent.com/hUI1BT3NMUG-uZ1lwJGilMG-pp8FGFp6o5ey0Wa6iRa-6VWhJEjUodanQzUMgWUgKDOMg_DPSvmXV9InflSpU13yQ59b2gQlNro_tlLNO-B1vdB5w3wXfTEUePYKqXa3EC1c13srJuTRGZnuot_RBYGYWe2qoFmB-nj7oac1OgnMJRrvUlCDDcvQlQ" alt=""><figcaption></figcaption></figure>

When you choose a 'Label key' and an operator, you can pick one of the existing 'Label values' from a list.&#x20;

Another pair of operators is 'contains' and 'not contains'. It allows you to use suggestions from a list or type in the value you require. With these operators you can see if labels in a selected 'Label key' contain the phrase you wrote down, or not.&#x20;

<figure><img src="https://lh5.googleusercontent.com/bRK7UX4jzptKHIwW4u_ryE6ghSzJUlIauMy8DHPnJMTpPRq6hKZgk8Q9USWM9aw5CDzwHdaMSbJeFUaLhz98-tBAmeNjxuxVK2POWHgN21u9pIwRDCOenP8czjTEGudLAM7X66-gtRWFTf1v0UqEGTKI68kyoLrOvn8ndnh3ibLw6eMCIBcZYv_SUA" alt=""><figcaption></figcaption></figure>

There are also numerical operators: 'greater than', 'greater than or equal', 'lower than', 'lower than or equal'. They refer to numerical values in 'Label value'.&#x20;

Example: if your 'Label key' is 'Cart', you can create a condition to see if a subscriber has more than 0 items in their cart. Use 'greater than' operator.&#x20;

<figure><img src="https://lh4.googleusercontent.com/V0QWSn_grVgdwdpmWqYcNjBm9ygLGy2O-4soD--V-RThYo2bTGDegvkx7ji5rWZkooTt3TKj7sgnqhmXUk-JD_DJADTqf8agP5kD2pyffgIQCcUeSUuf0h2lcR3PF7uwrfkZVCcpFS9eTIICJIdRZLyaHNCWqVlJPj6ihaQ2YbPCk9Yp4r4JWkyKaA" alt=""><figcaption></figcaption></figure>

The last pair of operators are ones addressing time. They are used with labels with 'Label value' presented in a form of a date. Those are 'after or equal time period' and 'before or equal time period'. By defining a  period to classify labels on subscribers, you can see if an action took place before or after that. The image below shows that only the subscribers who entered your website in the last seven days will be included in the segment.&#x20;

<figure><img src="https://lh3.googleusercontent.com/AbVI1uHOE1H970zWHflSKpUMYgaUMiXBWxdarpG4FecrDYPJTbfdETPZslkKCx9HXTIAY8332RlfCzCs34F5cuwnaqA-Vpt03bSmoI38EVLtB1FC-3hi0aUYXaTwRwvNIqBHqMua3-LrENYf2IByEnuF7Fztu8A0M081DtuiUQZ-7iMrLC5xBVnfwQ" alt=""><figcaption></figcaption></figure>

After you create a segment with all required conditions you can save it as a draft (click 'Save draft' in the top-right corner of the creator) or count it and allow usage in a campaign by clicking 'Save'.&#x20;

After the segment is counted you'll see the number of subscribers meeting its criteria. This group will receive a campaign targeted to this segment.&#x20;

A saved segment will show on the Segment list. A green color indicates that it's correctly counted and ready for usage. If it's still being counted, it will be highlighted in yellow. Drafts are marked in grey.&#x20;


# Copy Segment

If you want to copy a segment, click ![](/files/FcackepQvuUhDw4vBC8y) on the segment list.&#x20;

If you want to create a segment similar to the one already prepared, you can copy it. The existing segment will be doubled, but not counted.&#x20;

It means that the new segment will be counted after it's edited and the changes are saved.&#x20;


# Update Segment

If you want to edit a segment, click ![](/files/0eHUfoLN9tajlnbcgf1W) on the segment list. &#x20;

There are the following rules for edition:&#x20;

&#x20;\- The segment will not be counted if you only change the segment name.&#x20;

&#x20;\- If you change conditions, the segment will be marked as deleted (so the sending processes will still be able to use it). Then, a copy with the same name and conditions will be counted - and it will receive the 'Ready' status.&#x20;


# Delete Segment

If you want to delete a segment, click ![](/files/3I2x61HqPESEt1tjJSEc) on the segment list.&#x20;

A segment can be deleted only if it's not included in any planned campaigns.&#x20;

Deleting the segment means that all its connections to subscribers will be deleted as well.&#x20;

If you create the same segment as the one you deleted, it will be counted again.&#x20;


# Geolocation

If you want to use geolocation when sending mass campaigns, you first need to configure your application to gather the data about the subscriber's location.

To do this, follow the instructions below:

1\. Go to the Project settings tab and enable geolocation.

From this moment the application will download data about the location of subscribers based on their last visit to the website and data provided by the given browser.

NOTE: Each of your subscribers will receive a one-time pop-up requesting access to their location immediately after entering your website. If the subscriber does not give consent or such a notification has not yet been displayed (since geolocation was not enabled on your site), the default location will depend on the IP address provided by the user’s Internet provider.<br>

<figure><img src="/files/IlllbsOdehSJdTSJtkWc" alt=""><figcaption></figcaption></figure>

2\. Create polygons or specific locations that you will want to use in your mass campaigns. To do this, go to the Geolocation tab and click the "New polygon" button.\
\
Polygons can be specific cities, provinces, countries or more specific locations.

<figure><img src="/files/LhlYEkac6zxIo5ni0k1u" alt=""><figcaption></figcaption></figure>

* in place "A" search for the location you want to use as a basis for a new polygon
* wait until the territorial range appears on the map
* in place "B" enter the name of the polygon and click Save.

<figure><img src="/files/sxd5EE9nMyo2dGxMAS30" alt=""><figcaption></figcaption></figure>

NOTE: You can also manually specify the territorial range of the new training ground. All you have to do is define your location in the location search engine using the Polygon border drawing tool.

<figure><img src="/files/DyHmY06KaBpKCF22ORPK" alt=""><figcaption></figcaption></figure>

**Remember to name a new polygon every time you define your territorial range.**

You can use polygons as soon as they are created.

3\. To send a mass campaign to users in a particular location, with its configuration in the Audience step, click Select polygons.

<figure><img src="/files/VRE9rn14B9w6kohY90W9" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/vS9R4439gARAFXXpdMim" alt=""><figcaption></figcaption></figure>

\
NOTE: Information on the number of subscribers assigned to polygons is verified at the time of campaign sending. You can check the number of subscribers receiving the campaign only after it is sent.


# Campaigns

In PushPushGo, there are three types of campaigns you can send depending on your needs and expectations. Instead of one complicated sending procedure, you can use:&#x20;

* [Push Campaign](/campaigns/push-campaign) - campaigns addressed to your whole subscriber base or a targeted groups of users.
* [AB Test](/campaigns/ab-test) - allowing you to test the clickability of different variants of the intended campaign.&#x20;
* RSS campaign - campaigns sent automatically using the RSS feed connected with your website.

<figure><img src="/files/mjTYAwhue1jU4BCW4q6t" alt=""><figcaption></figcaption></figure>


# Push campaign

Push campaign creator allows you to send mass campaigns to all of your subscribers or reach groups of subscribers interested in a specific subject.


# Create Campaign

The first step in creating a Push campaign is to click the "New campaign" button on the right side of the main Dashboard.

<figure><img src="/files/rnVHfbfRg9dDMLJQGyNP" alt=""><figcaption></figcaption></figure>

Next, you need to: &#x20;

&#x20;\- [Fill in the content](/campaigns/push-campaign/create-campaign/content)

&#x20;\- [Choose the audience](/campaigns/push-campaign/create-campaign/audience)

&#x20;\- [Pick the sending time](/campaigns/push-campaign/create-campaign/time)

You can save the campaign as a draft and[ accept it later](/campaigns/push-campaign/create-campaign/drafts), or schedule the sending right away.&#x20;


# Content

{% hint style="info" %}
If you paste a link with correct metadata connected into a **link** field, the system will automatically upload the data, speeding up the preparation process.
{% endhint %}

A campaign must include a title, content, a link, and an image. You can also add up to two action buttons and a large image.&#x20;

<figure><img src="/files/NN4xxHjNOsWZsDLWkISX" alt=""><figcaption></figcaption></figure>

The requirements for each field are as follows:&#x20;

&#x20;\- **Title** - max. 50 signs, can't be empty.

&#x20;\- **Content** - max. 150 signs, can't be empty.

&#x20;\- **Redirect link** - has to be a correct URL address, to which the subscriber will be transferred after clicking on a notification.

&#x20;\- **Icon** - downloaded from the project's logo. The default app icon will be used if a logo is not defined.&#x20;

&#x20;\- **Image** - optional.

&#x20;\- **Action buttons** have a title and URL addresses that take the subscriber to the correct page when clicked.

&#x20;\- **Require interaction** - if you choose that option, the notification will not be hidden until the subscriber interacts with it.&#x20;


# Personalization

Nunjucks

In the process of personalization, you send campaigns with messages tailored to each subscriber.&#x20;

In the personalization, use nunjucks syntax. It allows you to access previously prepared labels.&#x20;

An example of nunjucks:&#x20;

**Title**: `Hello {{name}}!`

If there's no such label, nothing will render in this place.&#x20;

A subscriber with the `name: "Mateusz"` label will see "`Hello Mateusz`" in their push.

{% hint style="warning" %}
You don't have to do anything to choose the type of personalized campaign. All you need is to use the nunjucks syntax in the Title, Content, or Link fields. &#x20;
{% endhint %}

There are fields for personalizing the message in the campaign. They are available in the "Personalization" section.

<figure><img src="/files/uSkrOuNITnnKyoPkquvD" alt=""><figcaption></figcaption></figure>

Use those variables in your content and you'll see how the message may look to a given subscriber.&#x20;

<figure><img src="/files/Hl24OEWDX9SqqtTB7sLL" alt=""><figcaption></figcaption></figure>

If you want to see how the personalized message looks for another subscriber, refresh the site using the "Refresh" button ![](/files/sxpQuEIxkK9x4U8EbS35)


# Audience

To select a group of recipients for your campaign, you can use one of the three following options.&#x20;

<figure><img src="/files/4U7pkbnE1AhrKa7Bzb9k" alt=""><figcaption></figcaption></figure>

{% hint style="warning" %}
"All subscribers" is the default option.
{% endhint %}

{% hint style="info" %}
You can choose only one targeting option in the Push campaign creator.&#x20;
{% endhint %}

You can choose one of the following targeting options:&#x20;

&#x20;\- All subscribers - campaign will simply be sent to all of your subscribers.

&#x20;\- [Select Segment](/campaigns/push-campaign/create-campaign/audience/by-segment) - send your campaign to a previously created segment. It's the most effective option. The dispatch is fast, the subscriber segments are stable, and the risk of choosing the wrong label is low. Most of all, the number of subscribers is well-defined.&#x20;

&#x20;\- [Select Labels](/campaigns/push-campaign/create-campaign/audience/by-labels) (legacy support) - choose specific labels available for the project. Agility is a big advantage of this method, but it comes at a certain price: it slows the process and you can't know the number of targeted subscribers prior to sending the campaign.&#x20;


# By Segment

{% hint style="info" %}
Remember that this is the fastest option - choose it if time is of the essence.&#x20;
{% endhint %}

You can choose a previously created [**segment**](/subscribers/segments).

<figure><img src="/files/xmMC9dIgsUMYjPwrBv0B" alt=""><figcaption></figcaption></figure>

The chosen and clicked segment will be highlighted in green. The information about it will also be shown in the "Campaign will be sent to subscribers from segment:" field.


# By Labels

{% hint style="warning" %}
Remember that you can't see the number of subscribers before sending the campaign with labels. If you need this information, choose segments.&#x20;
{% endhint %}

You can select the labels directly:&#x20;

<figure><img src="/files/Pp472JXIAifQkdDTOSzJ" alt=""><figcaption></figcaption></figure>

Choose the labels and one of the strategies (OR / AND). If you choose OR, every subscriber with at least one label will be included. If you pick the AND strategy, all the selected labels have to be added to a subscriber to send them a push.&#x20;


# Provider options

This section contains options related to providers (web and mobile apps, divided into Android, Huawei, and iOS). **Shared options** are applied to all push notifications unless overridden by more specific ones (e.g., web-specific).&#x20;

<figure><img src="/files/QedXNuDIAR8PJ4ICMZ9f" alt=""><figcaption></figcaption></figure>

The available options include:

* **Priority (push priority):**\
  A parameter defining the priority of the push notification. Higher priority ensures faster delivery of the message but may increase battery usage on the user’s device.

{% hint style="warning" %}
We do not recommend using the high priority settings for all your campaigns. If this setting is overused, the provider (Vapid, iOS, Android, etc.) might start treating your project as spamming and ban you from using high priority. If that happens, your campaigns will have a default, normal priority.
{% endhint %}

* **Topic (push topic):**\
  A parameter used for grouping notifications. By assigning a notification to a specific topic, notifications within the same topic will overwrite each other. This ensures the user receives all notifications but only the most recent one is displayed.
* **iOS Subtitle:**\
  A parameter available exclusively for iOS, allowing you to add a subtitle to the notification. It is displayed below the main title of the notification and enables the delivery of an additional, concise message that complements the main content.

<figure><img src="/files/oU605ItdqcZvoP28ifFi" alt=""><figcaption></figcaption></figure>

**Use case:** You are reporting a football match score via push notifications. You can overwrite the previous push with the latest score, ensuring that, for example, users who didn’t read earlier messages will only receive the most recent one.


# Time

In this section, you can specify the time of sending the campaign. Choose 'Send now' to apply the default expiry settings and send the campaign right away.&#x20;

<figure><img src="/files/84McysYv10ZWxOm21wbR" alt=""><figcaption></figcaption></figure>

When you choose 'Schedule campaign' you can pick the time of the campaign's dispatch as well as the expiration time.&#x20;

<figure><img src="/files/HpxGFj7rXiICudOmojn8" alt=""><figcaption></figcaption></figure>

The campaign's expiry date is particularly important when sending notifications regarding information that may be time-sensitive, like limited promotions or news. The expire date can be set between 1 hour and a maximum of 72 hours.


# Drafts

Campaigns saved as a drafts are available in the campaign creator after clicking the "Drafts" button:

<figure><img src="/files/ysLxMfYUlqFBs0D3a41O" alt=""><figcaption></figcaption></figure>

After clicking the button, a list of all saved drafts will appear on the right side.

<figure><img src="/files/twPgV5hU7mAfdznlco6Q" alt=""><figcaption></figcaption></figure>

Every campaign has the following action buttons:&#x20;

* Edit draft&#x20;
* Copy and send draft
* Delete draft

<figure><img src="/files/hNyhlE2kLoCEwRlaRZCy" alt=""><figcaption></figcaption></figure>


# Campaign List

The Campaign List presents currently planned or previously sent push campaigns and allows you to perform certain actions: delete, create a new campaign on the basis of one previously prepared, view or cancel sending. &#x20;

<figure><img src="/files/AP9RVHBeETbXm1XzHcXb" alt=""><figcaption></figcaption></figure>

This view allows you to search campaigns and sort them by status or other criteria.&#x20;

Every campaign has the following action buttons:&#x20;

&#x20;\- [Copy and send](/campaigns/push-campaign/campaign-list/copy-campaign)

&#x20;\- [Copy campaign to another project](/campaigns/push-campaign/campaign-list/copying-and-pasting-campaigns-between-projects)

&#x20;\- [Cancel campaign](/campaigns/push-campaign/campaign-list/cancel-campaign)

&#x20;\- [Delete campaign](/campaigns/push-campaign/campaign-list/delete-campaign)

&#x20;\- [Campaign report](/campaigns/push-campaign/campaign-report)


# Cancel Campaign

You can only cancel a campaign if it has a 'Ready' or 'Sending' status.&#x20;

&#x20;\- Ready - the campaign will not be directed to sent&#x20;

&#x20;\- Sending - the dispatch of the campaign will be stopped as fast as possible

Those statuses allow you to cancel the campaign - otherwise, the action won't be possible to perform.&#x20;

In order to cancel the campaign, choose one of the options:&#x20;

'**Stop campaign'** on the report view, in the top-right corner of the screen.

<figure><img src="/files/qBSimZ9ZYe4lAbNv2xrp" alt=""><figcaption></figcaption></figure>

Or click the **cancel** button on the campaign list. &#x20;

<figure><img src="/files/Xp7UZ2NEru129d3v0iBi" alt=""><figcaption></figcaption></figure>


# Copy Campaign

If you want to copy the campaign, click the 'Push' button ![](/files/JF01kU9KHXGHDoFMjB8k) in the campaign list and choose "Copy and send" option. A new campaign will be created and you'll be redirected to its editing panel.&#x20;

<figure><img src="/files/ufskW2JGlHFOtoF1GP8H" alt=""><figcaption></figcaption></figure>


# Copying and pasting campaigns between projects

If you want to copy a campaign and paste it into another project, you can do it in a few easy steps. What’s more, you can copy a campaign to all your projects or just a selected few. It’s up to you.&#x20;

The copying option will be available if you have more than one project on your account, including shared ones.&#x20;

<figure><img src="/files/NF4QE5HIxiYL6hRltIK8" alt=""><figcaption></figcaption></figure>

How to do it?\
Select a campaign and click on a Push button ![](/files/JF01kU9KHXGHDoFMjB8k) Then choose 'Copy to project' option.\
Choose the project you want to copy your campaign to in a modal that will pop up.&#x20;

<figure><img src="/files/prA2hTgCGGSQvmMhtvwQ" alt=""><figcaption></figcaption></figure>

To choose a project, click on a tile with its’ name. You can reverse the action by clicking again.

If you want to copy the campaign to all your projects, check the “Select all” checkbox.&#x20;

Click “Copy campaign” and the selected campaign will be copied to chosen projects and saved as a draft.&#x20;

Using this action, you can copy:&#x20;

* title
* content
* redirectLink
* actions
* requireInteraction
* big image

Caution! If you want the copied campaign’s link to be the same as the project link, you need to change it manually.&#x20;

You can copy campaigns with the “Sent”, “Draft”, and “Ready” status.&#x20;

Right after pasting to a new project, a campaign with 'Draft' status will have the time of copying set as 'Send time'. The 'Expire date' will be filled in accordance with the project's settings.<br>


# Delete Campaign

If you want to delete a campaign from the list, click <img src="/files/TCbFxIMIvTCNyHIisk68" alt="" data-size="original">

A pop-up will show up and you may confirm your decision.&#x20;


# Campaign Report

{% hint style="info" %}
This screen refreshes automatically, so you don't have to reload the site if you want to refresh the report.&#x20;
{% endhint %}

You will be redirected to Campaign Report right after you send a campaign.&#x20;

Right at the beginning, this view will display information about the campaign's current status. You can [cancel campaign](/campaigns/push-campaign/campaign-list/cancel-campaign) (if, for example, you'll notice a typo or a mistake in your push).&#x20;

After a while, when the campaign is sent, the view will change, showing statistics (general data in a pie chart, and more detailed information in the form of histogram).&#x20;

Campaign information:

<figure><img src="/files/C6dPXDWfu9j8AzkyIDG9" alt=""><figcaption></figcaption></figure>

General information:

<figure><img src="/files/w1o1cS5lRmRmCTmefn8f" alt=""><figcaption></figcaption></figure>

Data on distribution over time:

<figure><img src="/files/Zmwntwt91SEU3sHUnupO" alt=""><figcaption></figcaption></figure>


# AB test

AB test allows you to test push notifications on a chosen sample of a selected group of subscribers.&#x20;

Test push variants are sent to a selected pool of your subscribers to determine which version achieves better CTR results. The winner variant is then sent to the rest of the selected group of subscribers. You can choose the winner manually or set an automatic selection.&#x20;

By conducting an AB test you can verify which content, title, image, or any other setting performs better and gives you a higher CTR result. A test requires at least 2 and up to 10 push variants (further referred to as variants).&#x20;

![](/files/eRmpJa18vbB1pfdBpWGS)


# Create AB test

To create and send a new AB test, click on the arrow next to the "New campaign" button and select the "AB test" option from the list.<br>

<figure><img src="/files/yzN4qt1W3BUvrQwjOVGX" alt=""><figcaption></figcaption></figure>


# Variants

While working on your test, you can save it as a draft and come back to it later. However, you need to have a minimum of 2 and up to 10 variants in your test to proceed.

At the top of the Variants step you will see tabs, with one tab for each variant. To add a new variant, click on the ‘Add variant’ button on the right of the variants tabs.

Above each variant, there is a trash icon. The trash button deletes a variant.

![](/files/BkeSkj8Q4lU3TWDxck2J)

The variant's anatomy is the same as in the push creator. For a valid variant you need to provide:

* title
* message
* link

Other settings you can add or modify are:

* icon (if none is provided, we will use your project logo or, if you haven't uploaded any, the green image with the bell icon),
* image (big image visible in some browsers),
* require interaction option (for Chrome browsers only: variant will be displayed until user clicks on it),
* variant action buttons (up to 2 buttons).

Images for both icon and image can be uploaded from your device or you can choose some from your "Recently uploaded".

You can check how the current variant looks like in a notification’s preview located in a column on the right-hand side of the page.

If you have set up some default settings (the gear icon on the right side), such as:

* UTM parameters,
* action buttons,
* expire date,
* require interaction.

they will be automatically applied to your variants, but you can modify them as you like.

<figure><img src="/files/LtAZMv8dvYEGhMHNoGtS" alt=""><figcaption></figcaption></figure>


# Audience

In this step, you can choose the group of subscribers to whom the AB test will be sent to. The audience can be selected by segments or labels. <br>

<figure><img src="/files/sRIcJGcOAwOndKlwGTjB" alt=""><figcaption></figcaption></figure>

In this step, you also need to select the percentage of the audience that will participate in the test. The selected sample has to be at least 1% and up to 50% of the targeted group. You need to have at least one subscriber for each variant to make the test work. To choose the percentage of the tested group, type a value in the input or set a value with a slider.

How does the division of subscribers between variants work?&#x20;

Example: You have 100 subscribers, and you decide to have 2 variants in the AB test.

If you choose a 20% split part, it means that from all of your 100 subscribers, 20% will receive test variants: which equals 20 subscribers.

These 20 subscribers will be split into two groups, one for each of the 2 variants, so each variant will be sent to 10 subscribers.

To sum up, for the given scenario the first variant would be sent to 10 subscribers, the second variant to 10 subscribers, and the winner to the remaining 80 subscribers.


# Provider options

Options related to providers (web and mobile apps, divided into Android, Huawei, and iOS). **Shared options** are applied to all push notifications unless overridden by more specific ones (e.g., web-specific).&#x20;

<figure><img src="/files/QedXNuDIAR8PJ4ICMZ9f" alt=""><figcaption></figcaption></figure>

The available options include:

* **Priority (push priority):**\
  A parameter defining the priority of the push notification. Higher priority ensures faster delivery of the message but may increase battery usage on the user’s device.
* **Topic (push topic):**\
  A parameter used for grouping notifications. By assigning a notification to a specific topic, notifications within the same topic will overwrite each other. This ensures the user receives all notifications but only the most recent one is displayed.
* **iOS Subtitle:**\
  A parameter available exclusively for iOS, allowing you to add a subtitle to the notification. It is displayed below the main title of the notification and enables the delivery of an additional, concise message that complements the main content.

<figure><img src="/files/oU605ItdqcZvoP28ifFi" alt=""><figcaption></figcaption></figure>

**Use case:** You are reporting a match score via push notifications. You can overwrite the previous push with the latest score, ensuring that, for example, users who didn’t read earlier messages will only receive the most recent one.


# Time

There are two ways to send your test:

* Send now,
* Schedule AB test.

By choosing the ‘Send now’ option, your test will get a set of already configured settings :

* AB Test will start instantly,
* last 15 minutes,
* the winner will be chosen automatically based on CTR (in case of equal CTRs, the variant with higher Clicked value will be selected, and for equal Clicked values, the winner will be sent randomly),
* and the winner's expiration date will be set according to your Default setting Expire Date (the gear icon on the right side) or default 72 hours.

![](/files/bUTumbyj86UrTgFVqPUo)

If you want to modify the time settings by yourself, switch to ‘Schedule campaign’.

In the ‘Schedule campaign’ you need to set:

* test start date,
* test end date (in a range from 15 minutes to 72 hours from the test start date),
* winner selection type.

For winner selection type, you can choose between:

* automatically sending a variant with a higher CTR result,
* choose variant manually.

If you want us to choose the winner automatically, you’ll also need to provide:

* winner send date (up to 72 hours from the test end date),
* winner expire date (in a range from 1 to 72 hours from winner send date).

![](/files/FBhuAU0xJDNjcdeEDErQ)


# Save draft or accept a test

Once your test is created, you can save it as a draft, send to yourself or proceed with it by clicking the ‘Send campaign’ button.

If you want to proceed with the AB test and send it, we will prepare the subscribers group for your variants and a winner.&#x20;

In this step, we randomly split subscribers from the group chosen earlier - equal chunks for variants and the rest for the winner. Then we allocate them in a partition where they will be waiting for the test start date.

![](/files/xsJRWib2M6UE4mZ1V91l)

![](/files/QBZ9nAP6euHvPnlWnvIZ)

Now you can relax and wait for the AB test results :tada:

If  your subscribers sample is too low, we won't be able to prepare the test partition, and your test will be marked as failed. Remember that the sample requires a minimum of 1 subscriber for each variant in the AB test.


# AB test list

Click “Campaigns” on the menu, then switch the select button to “AB” in the upper-left corner. (left-side navigation > Campaigns > AB).

![](/files/xvPGQ2gCrFsaCoc2CN7U)

![](/files/9RWHN2Zw2Xb3CCKUvHFF)

There, you have a list of all your AB tests.

To find the particular AB test, type its name in the search box.

To see only the tests with a specific state, use the select menu in the upper right corner of the list.

For example, if you want to see the tests in which manually choosing a winner is required, select “Winner ready to send”.

Also, you can sort your AB tests by the date of their creation, sending and ending.

![](/files/JV0kBdLt2hrKnM1qAs9F)


# Winner selection

You need to manually select a winner variant in one of these two scenarios:

* if you’ve chosen a manual winner selection when creating a test,
* if each variant's CTR is equal 0%.

In either of those cases, we will send you an email with the information.

:information\_source: The winner has to be selected up to 72h after the end test date, otherwise the test will be marked as failed.

To choose a winner, you need to go to the list of your AB tests (left-side navigation > [Campaigns](https://app.pushpushgo.com/campaign/list/push/all) > [AB](https://app.pushpushgo.com/campaign/list/ab/all)) and find a test with a [Manual win](https://app.pushpushgo.com/campaign/list/ab/manual-win) state (you can use a filter, if you have more tests). The test which needs a manual winner selection will have the ‘Choose a winner’ status and will look similar to the one on the image below:

![](/files/8VPdPMGd5Oo846q6z90y)

Next, click on a button with the winner cup icon, to get to a test’s details page. Here you can see the test’s summary and compare which of the variants brought you the best results.

Results are presented in a table and bar chart. Presented data include sent, delivered, clicked, CTR, and DSP (delivered divided by sent).

![](/files/TaOPSWhTHRmlwQQhqJsI)

Once you decide which variant should be sent to the rest of the group selected for the test, click ‘Select’ on the table.

![](/files/UgCjBPHi1Nz9w6WZl4IU)

The final information we need is:

* winner send date (up to 72 hours from the test end date),
* winner expire date (in a range from 1 to 72 hours from winner send date).

Select the dates and confirm your choice to complete the selection process for the winning variant.

![](/files/PtBMp1IvzpJakapHJkEZ)

Once the winner variant is selected, you’ll see its details next to the test variants’ details. Winner variant statistics will be visible after the winner expire date passes.

![](/files/WCIY32NPFXHqCrsTTmBl)


# AB test report

To consult an AB test report and details, you should go to the AB test list view (left-side navigation > Campaigns > AB test), and select the test you’re interested in by clicking on the report button:

![](/files/CiQKtm9iFWrCUKBhSe3R)

On the report page, you can see your test details and settings. If the test has a winner selected, we can see the winner’s details. If the test's winner had already been sent and its expire date has passed, you will be able to see its results.

![](/files/QYL8BycMGXVqWPxZDnNE)

After the test end date you can verify the variants’ results (sent, delivered, clicked, CTR, and DSP (delivered divided by sent). If there’s no data collected (ex. if the test has failed at some point), you’ll see an empty table and data.

![](/files/wJlmkddd7nulHHxBRJ1s)

![](/files/btalzeeT7ADBOcKv857r)


# Cancel AB Test

From the moment your AB Test has been accepted, you can cancel it. All you need to do is click the “Stop AB test” button located right next to the chosen test on the AB Test List.&#x20;

![](/files/mJYoMXbrkwLEcAailxbW)


# Send AB test saved as draft

If you want to send an AB test previously saved as a draft, you need to go to the AB test creator, click the Drafts button, and find your test.

Once you find your test, click the 'Edit AB test' button, which will redirect you to the AB test creator. There, if everything is set as you want, you can proceed with the test by clicking the 'Send campaign' button.

![](/files/h6yPzl80rPRBDxLe6MmA)


# Resend AB test

If you want to edit the existing AB test or resend one of your previous tests, go to the AB test campaigns list (left-side navigation > Campaigns > AB test) and click the 'Push' button. You'll be redirected to the AB test creator, which will be filled with settings from the AB test you wanted to resend.

![](/files/RzZHqJVGNHvyVuMqsB1Q)


# Delete AB test

If you want to delete one of your AB tests, go to the AB test list view (left-side navigation > Campaigns > AB test) and click the 'Delete test' button.

![](/files/8NMZlruAI3WsusHDMfg2)


# RSS campaign

<figure><img src="/files/pJa9IFeSMWK2qB6BdTl3" alt=""><figcaption></figcaption></figure>

Automate the content distribution process and reduce the time spent on creating push campaigns. Integration with RSS enables the PushPushGo app to retrieve the title, description, image, and link from the XML file as soon as it is updated and to send automatic push notifications to subscribers.




---

[Next Page](/llms-full.txt/1)