PushizoDocs
Integrations

Integrations: Segment, Amplitude, Mixpanel, GA4, PostHog, RudderStack, HubSpot, Salesforce, ActiveCampaign, Adobe Audience Manager, BlueConic, Median, Andromo, Retool, Zapier, Slack, WordPress, WooCommerce, Shopify, GTM

Ready-made integrations for connecting Pushizo to your data and automation stack without writing code (ADR-0031). Managed in the dashboard under Developer → Integrations (webhooks.manage permission: developer and admin roles).…

Ready-made integrations for connecting Pushizo to your data and automation stack without writing code (docs/adr/0031-entegrasyonlar-ve-mcp-sunucusu.md). They are managed in the dashboard under Developer → Integrations (webhooks.manage permission: developer and admin roles). Each integration is connected once per app.

Common behavior

  • Credentials are stored with envelope encryption; in responses and on screen they only appear masked (•••• + last 4 characters). When updating, any credential field you leave empty is kept; to clear a field, send an empty value.
  • The Test connection button validates the credential with the provider. If the provider returns 401/403, the integration is moved to the Error state and no requests are sent; it becomes active again once you update the credential.
  • Recent runs: event deliveries, cohort syncs, incoming requests and tests (retained for 30 days).
  • Outgoing events (Segment/Amplitude/Mixpanel destination, Zapier, Slack) are written to an outbox and sent in batches by the worker every 5 seconds. On transient errors (429, 5xx, network) the wait is 30 s → 2 min → 10 min → 30 min → 2 h → 6 h (or Retry-After if it is longer); on the seventh failure or a permanent error (400/413/422) the event is dropped.
  • Disconnecting deletes the credentials, Zapier subscriptions and pending events.

Analytics destinations: events sent

The following Pushizo events can be sent to Segment, Amplitude and Mixpanel: event.received, subscription.created, subscription.unsubscribed, delivery.sent|delivered|failed|opened|clicked|bounced|unsubscribed, in_app.impression|clicked|dismissed, conversion.created, journey.entered|completed. For event.received you can optionally provide an event name filter (up to 50 names).

  • System events are sent with Segment Spec "Object Action" names (Notification Opened, Subscription Created …); custom events keep their own names.
  • The user is identified by external_id; if there is none, the Pushizo user ID becomes the anonymous ID (Segment anonymousId, Amplitude device_id, Mixpanel distinct_id). The subscription token (push token) is never sent.
  • The deduplication key is the event ID (Segment messageId, Amplitude insert_id, Mixpanel $insert_id); retries do not create duplicate records at the destination.

Segment

Pushizo can act as both a Segment destination (Pushizo → Segment) and a source (Segment → Pushizo).

Destination (sending events)

  1. In Segment, create an HTTP API source and copy its Write Key.
  2. In Pushizo, enter the Write Key on the Segment card, choose the region (US/EU) and select the events to send.
  3. Events go to the Segment HTTP Tracking API /v1/batch endpoint (request ≤ 450 KB; a single message over 32 KB is not sent).

Source (data coming from Segment)

  1. In Pushizo, enable the Incoming endpoint and set a shared secret. The card shows the incoming endpoint URL: {API_URL}/hooks/integrations/segment/{integrationId}.
  2. In Segment, add the Webhooks (Actions) / Webhooks destination to your source; enter this URL and the same shared secret for signing.
  3. Every request must be signed with the X-Signature header: the HMAC-SHA1 digest (hex) of the body using the shared secret. Unsigned or incorrectly signed requests are rejected; if the incoming endpoint is disabled or the integration is not active, 404 is returned.

The body can be a single message, an array of messages or { "batch": [...] }; a batch request can contain at most 1000 messages. The body limit on this endpoint is 500 KB (Segment's largest documented batch size); on other /hooks/* endpoints it is 256 KB. Requests over the limit are rejected with 400 HS_BAD_REQUEST (the same response as the general body limit).

Segment callPushizo equivalent
identifyCreate/update user (userId → external_id). traits are written to properties by default; if as tags is selected in the settings, only string/number/bool values become tags
trackEvent (source=import). The name is adapted to [a-zA-Z0-9_.:-] characters and the original name is stored in the segment_event property. A user is created for an unknown userId, so the event is reflected in segment conditions immediately
groupproperties.group + the segment_group_id tag
page, screen, aliasIgnored

Events coming from Segment are not sent back to the Segment destination (loop prevention). If an identify/group is rejected, the other messages in the same batch request continue to be processed.

Amplitude

  1. Get the API Key and Secret Key from Amplitude Settings → Projects (the Secret Key is required for cohort sync).
  2. In Pushizo, enter the keys on the Amplitude card and choose the region (US/EU).
  3. Sending events: select the events to send (HTTP V2 API, 500 events per request).
  4. Cohort sync: add cohort IDs (up to 20) and choose the sync interval (15 min – 7 days, default 60 min). Cohorts are downloaded with the Behavioral Cohorts API.

Mixpanel

  1. Create a service account (with access to the project) in Mixpanel Organization Settings → Service Accounts and note the Project ID.
  2. In Pushizo, enter the service account username/secret, Project ID and region (US/EU/IN) on the Mixpanel card.
  3. Sending events: Import API (strict=1, 1000 events per request; records rejected by Mixpanel are dropped individually).
  4. Cohort sync: add cohort IDs (up to 20); members are read page by page with the Engage Query API.

Cohort sync (Amplitude and Mixpanel)

  • Cohort membership is carried as a tag: the cohort_amp_<id> (Amplitude) or cohort_mxp_<id> (Mixpanel) tag is added with the value "1" to the external_ids in the cohort, and removed from those who leave the cohort. The sync is a single transaction, so partial results are never visible.
  • On the first sync, a dynamic segment with the condition tags.<tag_key> exists is created (if deleted, it is recreated on the next sync). You can use this segment directly for campaign, journey and in-app targeting.
  • No users are created for members that have no match in Pushizo; their count appears as unmatched in the run record.
  • An error in one cohort does not stop the others (partial). The Sync now button brings the sync forward; the worker runs it within 1 minute at most.

Important: Disconnecting the integration does not delete the cohort tags (cohort_amp_<id> / cohort_mxp_<id>) or the dynamic segment created by the sync; they remain on users and in the segment list. If you no longer need them, remove the segment from Audience → Segments and the tags manually via the API ({"tags": {"cohort_amp_<id>": null}} in the body of PATCH /v1/apps/{app_id}/users/by/external_id/{id}). If any campaign or journey uses this segment, update them first.

Zapier

The Pushizo Zapier app (integrations/zapier) uses REST Hook triggers; events reach your Zap in less than 1 minute.

  1. Create a key in the dashboard under Developer → API keys. users:read for triggers; users:write, events:write, notifications:write depending on the actions you will use.
  2. When adding the Pushizo connection in Zapier, enter the API key and the App ID (for a self-hosted installation, enter your API root URL with https in the API URL field).
  3. Zapier subscribes when the Zap is turned on; the subscription is deleted when it is turned off. Subscriptions are listed on the Integrations → Zapier card.
TriggerPushizo event
New Subscribersubscription.created
New Eventevent.received (optional event name filter)
Notification Delivered / Opened / Clickeddelivery.delivered / delivery.opened / delivery.clicked
New User / User Tags or Properties Changeduser.created / user.updated
ActionEndpointScope
Upsert UserPOST /v1/apps/{app_id}/usersusers:write
Set TagsPATCH /v1/apps/{app_id}/users/by/external_id/{id}users:write
Send EventPOST /v1/apps/{app_id}/eventsevents:write
Send NotificationPOST /v1/notificationsnotifications:write

The hook URL must be public HTTPS; at most 200 subscriptions per app. A subscription is removed automatically when: Zapier returns 410 Gone, 50 consecutive permanent errors occur, or the API key that created the subscription is revoked, expires or is deleted. Public endpoints: GET /v1/apps/{app_id}/integrations/zapier/me, POST …/hooks, DELETE …/hooks/{hookId}, GET …/samples (scope users:read).

Slack

Campaign started/completed, message failure, campaign approval request and quota threshold notifications are sent to a Slack channel. Messages use Block Kit format, in Turkish or English.

ModeSetupWhen
Incoming WebhookSlack app → Incoming Webhooks → add to channel; enter the https://hooks.slack.com/… URLNotifications only; fastest setup
Bot tokenSlack app → OAuth & Permissions → bot scopes → install to workspace; enter the xoxb-… token and the channel (C0123ABC or #pazarlama)Approve/reject from Slack and channel selection

Required bot scopes in bot mode: chat:write, users:read, users:read.email. Invite the bot to the channel (/invite @Pushizo).

Campaign approval from Slack

  1. Choose bot mode, enter the Signing Secret (Slack app → Basic Information) and enable Approval from Slack.
  2. Enable Slack app → Interactivity & Shortcuts; enter the URL shown on the card as the Request URL: {API_URL}/hooks/integrations/slack/{integrationId}/interactions.
  3. Approve/Reject buttons appear in the approval request message. The Slack user who clicks the button is matched to a Pushizo member by email address; the member must be active, have the campaigns.approve permission and have access to the app. On rejection, the campaign stays as a draft.

Requests are verified with the Slack signature (v0= HMAC-SHA256, 5 min time window).

WordPress plugin

integrations/wordpress/pushizo (WordPress ≥ 6.2, PHP ≥ 8.1).

  1. Upload the pushizo folder to /wp-content/plugins/ and activate the plugin.
  2. Enter the App ID under Settings → Pushizo (you can copy it from the Integrations → WordPress card). For a self-hosted installation, change the API URL field.
  3. The plugin loads the Web SDK on every page and serves the service worker from the site root (/PushizoSDKWorker.js). You can optionally enable the slidedown or the bell. If the worker returns 404, save Settings → Permalinks once.
  4. For a subscription form, use the [pushizo_subscribe] shortcode or the Pushizo subscribe form block (optional email field).
  5. Notify on publish: when enabled, a notification is sent when a post of the selected post types is published (segment selection and a per-post meta box). This requires a REST API key with the notifications:write scope; the key is never written to pages.

WooCommerce

The WordPress plugin hooks in when WooCommerce is installed (includes/class-pushizo-woocommerce.php). Product views, add-to-cart and checkout start are sent via the Web SDK. Orders (order_placed) are sent with the stored REST API key to the POST /v1/apps/{appId}/events endpoint (events:write). The key is never written to the page. Without a key, the order event is skipped. Email, phone and address are not sent.

Shopify

integrations/shopify. The theme snippet sends product_viewed, product_added_to_cart and, in the cart, checkout_started. Orders arrive at the POST /hooks/shopify/{appId} endpoint with the signing secret saved in the dashboard (orders/paid or orders/create, not both). The secret is stored encrypted. Web push is not part of this snippet: a Shopify theme cannot place a service worker at the site root. Details in integrations/shopify/README.md.

Google Tag Manager template

Web Custom Template; source and releases: github.com/pushizo/pushizo-gtm-template (ready for submission to the Community Template Gallery: template.tpl, metadata.yaml, Apache 2.0 LICENSE).

  1. In GTM, go to Templates → Tag templates → Search Gallery → "Pushizo Web Push" (until it is in the gallery: use New → Import to upload template.tpl from the repository and save it).
  2. Create a tag of type Pushizo Web Push; enter the App ID (and the API URL if needed).
  3. Actions: Initialize (with the Initialization – All Pages trigger), Send event (name, optional numeric value, properties), Add tags (key/value), Log in (external ID). Each action first loads the SDK and initializes it idempotently.
  4. The service worker file (PushizoSDKWorker.js) must be served from your site root; if you use a different path, enter it in the template's Service worker path field.

The template's permissions are limited to inject_script, access_globals and logging.

HubSpot

Connects with a private app token (pat-…). The URL is fixed to api.hubapi.com.

  • Contacts: changed HubSpot contacts are written to Pushizo users by email. The first run covers the last 24 hours. The external ID becomes hubspot:<contact ID>; if the same email exists, the existing user is updated.
  • Timeline: selected delivery, conversion and custom events are written to the contact card as notes. Rows without an email are skipped.
  • Permissions: crm.objects.contacts.read, crm.objects.contacts.write, crm.objects.notes.write.

Salesforce

Connects through a Connected App and works in both directions: Contact and Lead records come into Pushizo, and selected message activities are written to Salesforce as Tasks. Decision record: docs/adr/0067-salesforce-senkronu.md.

Setup:

  1. In Salesforce, go to Setup → App Manager → New Connected App. Enable the OAuth settings, add the api scope and check Enable Client Credentials Flow.
  2. Under Manage → Edit Policies, choose a user with sufficient permissions for Client Credentials Flow → Run As.
  3. In Pushizo, enter the My Domain URL, Consumer Key and Consumer Secret on the Integrations → Salesforce card.

Import:

  • The first run fetches all records, then only the changed ones. Each run processes 1000 records per object; the rest continues one minute later.
  • Matching order: the salesforce:<Id> external ID, the salesforce_id property, email.
  • Properties written: email, first_name, last_name, phone, salesforce_id, salesforce_object.
  • Additional fields: one per line as Tier__c=tier, up to 20 fields. Only string, number and boolean values are written.
  • Converted Leads are not imported. A record deleted in Salesforce is not deleted from Pushizo.

Export: whichever of the delivery.delivered, delivery.opened, delivery.clicked, conversion.created events you select are written as completed Tasks on the user's Salesforce record. Users without a Salesforce record are skipped; no contact or Lead is created.

Security: only *.my.salesforce.com URLs are accepted. The secret is stored encrypted and never returned in responses. If the credential becomes invalid, the integration moves to the error state and resumes once the credential is updated.

ActiveCampaign

Connects with an API key. Contacts and tags flow from ActiveCampaign into Pushizo; nothing is written in the other direction.

  • URL: https://hesabiniz.api-us1.com. For security, only the api-us1.com and activehosted.com domains are accepted. The URL and key are on the Settings → Developer page in ActiveCampaign.
  • Contacts: written to the existing user by email; if none exists, a user with the external ID activecampaign:<id> is created. Contacts without an email are skipped.
  • Tags: written with the ac_ prefix (VIP Müşteri → ac_vip_musteri, value true). A tag removed in ActiveCampaign is removed here too; your other tags are left untouched. At most 15 tags per contact are imported.
  • Frequency: the first run covers the last 24 hours. At most 300 contacts are processed per run; the rest carry over to the next run. ActiveCampaign's limit of 5 requests per second is respected.
  • Usage: build segments with the tags. Connect a journey with the "segment entry" trigger.

There is no Pushizo action inside ActiveCampaign automations: that action would require publishing in ActiveCampaign's own app marketplace.

Adobe Audience Manager

Segment membership comes into Pushizo through Adobe's real-time outbound transfer.

  1. On the Integrations page, open the Adobe Audience Manager card, enter a signing key of at least 16 characters and save.
  2. Give your Adobe consultant the displayed URL, the signing key, the header name (default X-Signature) and the algorithm (default HMAC-SHA256). The destination is defined on the Adobe side by the consultant.
  3. Pushizo external_id values must match the ID in Adobe. The matching field is DataPartner_UUID by default; AAM_UUID can be selected if needed.
  • Each segment becomes a tag: aam_14356, value true. When Status: 0 arrives, the tag is deleted. Build your segment with this tag.
  • No user is created for an ID that does not exist in Pushizo; it is counted as unknown_user.
  • The body signature is verified over the raw bytes. Unsigned or invalid requests return 401.

Not tested with a real Adobe account; the format and signature were implemented according to Adobe's documentation.

BlueConic

Nothing extra is needed on the server side: the BlueConic webhook calls the public API's user update endpoint. Data flows from BlueConic into Pushizo.

  1. Add the BlueConic ID to the user as an alias:
curl -X PATCH "https://api.pushizo.com/v1/apps/$APP_ID/users/by/external_id/$EXTERNAL_ID/identity" \
  -H "Authorization: Bearer $PUSHIZO_API_KEY" -H "Content-Type: application/json" \
  -d '{"identity":{"blueconic_profile_id":"BLUECONIC_ID"}}'
  1. Create an API key with the users:write scope.
  2. Configure the webhook connection in BlueConic as follows. Method PATCH, header Authorization: Bearer <key>, URL:
https://api.pushizo.com/v1/apps/APP_ID/users/by/blueconic_profile_id/{{blueconic_profile_id}}
  1. In the body, write the profile field and the segment to tags. null deletes a tag:
{ "tags": { "blueconic_sehir": "{{city}}", "blueconic_vip": "true" } }

Median (GoNative)

Adds native push to the Median app that wraps your website. Web push does not work in Median's WebView, so Median's Firebase Cloud Messaging plugin is used instead.

  1. In Median App Studio, enable the Firebase Cloud Messaging plugin and add the google-services.json file.
  2. Enter the service account of the same Firebase project in the Android push channel in Pushizo.
  3. On your site, get the token and register it with Pushizo:
median.firebaseMessaging.register({
  callback: async ({ token }) => {
    if (!token) return;
    await fetch(`https://api.pushizo.com/sdk/v1/apps/${APP_ID}/subscriptions`, {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify({ channel: 'android_push', token, user: { external_id: USER_ID } }),
    });
  },
});

Limitation: this method works on Android only. On iOS, Median provides an FCM token, while the Pushizo iOS channel requires an APNs token. If identity verification (identity_hash) is enabled, add it to the user field as well.

Andromo

Andromo lets you choose a push service only from a list in its own dashboard, and Pushizo is not on that list. Therefore Pushizo push cannot be connected directly to an Andromo app.

  • If you can build the app yourself, set it up with docs/guides/docs/sdk/android.
  • If your content is a website, use the Median route or web push with the Web SDK on the site.

Retool

Connects through Retool's REST API resource; there is no dedicated Pushizo resource.

  1. Resources → Create new → REST API. Base URL: https://api.pushizo.com.
  2. Header: Authorization: Bearer <key>. Create the key with only the scopes you need (e.g. users:read, notifications:write). The key stays on the Retool server.
  3. Queries:
TaskMethod and path
List usersGET /v1/apps/APP_ID/users
List segmentsGET /v1/apps/APP_ID/segments
Send notificationPOST /v1/notifications
List notificationsGET /v1/notifications

Set the send query to run manually and add a confirmation dialog; an automatic query could send by accident.

{
  "app_id": "APP_ID",
  "target": { "included_segments": ["{{ segmentSelect.value }}"] },
  "contents": { "tr": "{{ messageInput.value }}" }
}

GA4, PostHog, RudderStack

Dashboard → Integrations. Selected Pushizo events are sent through the outbox. The user is identified by external_id; if there is none, the Pushizo user ID is used. The push token is never sent.

  • GA4: measurement ID (G-…) and Measurement Protocol API secret. Event names are converted to GA4 conventions. Firebase Analytics requires the app ID; if app_instance_id is missing from an event, that event is skipped.
  • PostHog: project API key. Region US or EU. For a self-hosted instance, enter the https root URL.
  • RudderStack: write key and data plane root URL (https://….rudderstack.com). The body is the same as a Segment track. Private network addresses are rejected.

AppsFlyer, Adjust, RevenueCat

Dashboard → Integrations. Each requires a webhook secret per app. URL: POST /hooks/integrations/{appsflyer|adjust|revenuecat}/{integrationId}. The secret is sent via Authorization: Bearer, x-pushizo-token or ?token=. Pushizo makes no outgoing requests to these three.

  • AppsFlyer: customer_user_id, otherwise appsflyer_id. Properties: media_source, campaign.
  • Adjust: partner_parameters.external_id, otherwise adid.
  • RevenueCat: event.app_user_id. The event name starts with revenuecat_.

On this page