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-Afterif 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 (SegmentanonymousId, Amplitudedevice_id, Mixpaneldistinct_id). The subscription token (push token) is never sent. - The deduplication key is the event ID (Segment
messageId, Amplitudeinsert_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)
- In Segment, create an HTTP API source and copy its Write Key.
- In Pushizo, enter the Write Key on the Segment card, choose the region (
US/EU) and select the events to send. - Events go to the Segment HTTP Tracking API
/v1/batchendpoint (request ≤ 450 KB; a single message over 32 KB is not sent).
Source (data coming from Segment)
- In Pushizo, enable the Incoming endpoint and set a shared secret. The card shows the incoming endpoint URL:
{API_URL}/hooks/integrations/segment/{integrationId}. - In Segment, add the Webhooks (Actions) / Webhooks destination to your source; enter this URL and the same shared secret for signing.
- Every request must be signed with the
X-Signatureheader: 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,404is 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 call | Pushizo equivalent |
|---|---|
identify | Create/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 |
track | Event (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 |
group | properties.group + the segment_group_id tag |
page, screen, alias | Ignored |
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
- Get the API Key and Secret Key from Amplitude Settings → Projects (the Secret Key is required for cohort sync).
- In Pushizo, enter the keys on the Amplitude card and choose the region (
US/EU). - Sending events: select the events to send (HTTP V2 API, 500 events per request).
- 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
- Create a service account (with access to the project) in Mixpanel Organization Settings → Service Accounts and note the Project ID.
- In Pushizo, enter the service account username/secret, Project ID and region (
US/EU/IN) on the Mixpanel card. - Sending events: Import API (
strict=1, 1000 events per request; records rejected by Mixpanel are dropped individually). - 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) orcohort_mxp_<id>(Mixpanel) tag is added with the value"1"to theexternal_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> existsis 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
unmatchedin 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 ofPATCH /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.
- Create a key in the dashboard under Developer → API keys.
users:readfor triggers;users:write,events:write,notifications:writedepending on the actions you will use. - 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).
- 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.
| Trigger | Pushizo event |
|---|---|
| New Subscriber | subscription.created |
| New Event | event.received (optional event name filter) |
| Notification Delivered / Opened / Clicked | delivery.delivered / delivery.opened / delivery.clicked |
| New User / User Tags or Properties Changed | user.created / user.updated |
| Action | Endpoint | Scope |
|---|---|---|
| Upsert User | POST /v1/apps/{app_id}/users | users:write |
| Set Tags | PATCH /v1/apps/{app_id}/users/by/external_id/{id} | users:write |
| Send Event | POST /v1/apps/{app_id}/events | events:write |
| Send Notification | POST /v1/notifications | notifications: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.
| Mode | Setup | When |
|---|---|---|
| Incoming Webhook | Slack app → Incoming Webhooks → add to channel; enter the https://hooks.slack.com/… URL | Notifications only; fastest setup |
| Bot token | Slack 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
- Choose bot mode, enter the Signing Secret (Slack app → Basic Information) and enable Approval from Slack.
- Enable Slack app → Interactivity & Shortcuts; enter the URL shown on the card as the Request URL:
{API_URL}/hooks/integrations/slack/{integrationId}/interactions. - 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.approvepermission 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).
- Upload the
pushizofolder to/wp-content/plugins/and activate the plugin. - 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.
- 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 returns404, save Settings → Permalinks once. - For a subscription form, use the
[pushizo_subscribe]shortcode or the Pushizo subscribe form block (optional email field). - 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:writescope; 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).
- In GTM, go to Templates → Tag templates → Search Gallery → "Pushizo Web Push" (until it is in the gallery: use New → Import
to upload
template.tplfrom the repository and save it). - Create a tag of type Pushizo Web Push; enter the App ID (and the API URL if needed).
- 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.
- 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:
- In Salesforce, go to Setup → App Manager → New Connected App. Enable the OAuth settings, add the
apiscope and check Enable Client Credentials Flow. - Under Manage → Edit Policies, choose a user with sufficient permissions for Client Credentials Flow → Run As.
- 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, thesalesforce_idproperty, 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 theapi-us1.comandactivehosted.comdomains 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, valuetrue). 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.
- On the Integrations page, open the Adobe Audience Manager card, enter a signing key of at least 16 characters and save.
- 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. - Pushizo
external_idvalues must match the ID in Adobe. The matching field isDataPartner_UUIDby default;AAM_UUIDcan be selected if needed.
- Each segment becomes a tag:
aam_14356, valuetrue. WhenStatus: 0arrives, 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.
- 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"}}'- Create an API key with the
users:writescope. - Configure the webhook connection in BlueConic as follows. Method
PATCH, headerAuthorization: Bearer <key>, URL:
https://api.pushizo.com/v1/apps/APP_ID/users/by/blueconic_profile_id/{{blueconic_profile_id}}- In the body, write the profile field and the segment to tags.
nulldeletes 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.
- In Median App Studio, enable the Firebase Cloud Messaging plugin and add the
google-services.jsonfile. - Enter the service account of the same Firebase project in the Android push channel in Pushizo.
- 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.
- Resources → Create new → REST API. Base URL:
https://api.pushizo.com. - 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. - Queries:
| Task | Method and path |
|---|---|
| List users | GET /v1/apps/APP_ID/users |
| List segments | GET /v1/apps/APP_ID/segments |
| Send notification | POST /v1/notifications |
| List notifications | GET /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; ifapp_instance_idis 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 Segmenttrack. 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, otherwiseappsflyer_id. Properties:media_source,campaign. - Adjust:
partner_parameters.external_id, otherwiseadid. - RevenueCat:
event.app_user_id. The event name starts withrevenuecat_.
Exports and imports (CSV)
CSV export jobs (users, subscriptions, events, deliveries), signed download links, Pushizo and legacy provider CSV imports, error reports and retention periods.
MCP server: Pushizo with AI assistants
With its Model Context Protocol (MCP) server, Pushizo lets Claude Desktop, Claude.ai, Cursor and other MCP clients read your segment, campaign, message, template, journey, user, analytics and web growth data and…