Consent and privacy

How Kentro Pixel applies consent, quarantines sensitive data, applies a property's sensitive paths, page view settings and form field allowlist, and handles privacy requests.

Kentro Pixel decides per event whether it may be collected, based on the event's consent purpose, the visitor's consent snapshot and the property's consent settings. It also scans every event for sensitive data, applies the property's sensitive paths and page view settings, and handles export, deletion, anonymization and consent withdrawal requests for one person at a time.

In this page

  • Purposes
  • Property consent settings
  • What suppression means
  • Consent record
  • Sensitive-data quarantine
  • Sensitive path patterns
  • Page view settings
  • Form fields and lead details
  • Privacy requests
  • What a delete or anonymize request erases
  • Limits with external providers

Purposes

Every event has one consent purpose: analytics, marketing or functional. It is fixed per event by its schema (see Events). The envelope's consent snapshot gives a state per purpose: granted, denied or, when missing, unknown. Missing consent never counts as granted unless the property's settings say so.

Property consent settings

settings.consent is set at creation or with PATCH /v1/properties/:id. In Kentro GO, use the property's Settings tab.

SettingDefaultEffect
requireForAnalyticstrueEvents with the analytics purpose need analytics consent. When false, they are accepted unless analytics is explicitly denied.
requireForMarketingtrueThe same for events with the marketing purpose.
defaultWhenUnknowndeniedWhat unknown counts as when consent is required (granted or denied).
honorGpctrueGlobal Privacy Control denies marketing.

privacy_mode: "strict" forces both requirements on and defaultWhenUnknown to denied, whatever the settings say. Settings are merged one level deep: when you change consent, send the whole consent object, because keys you leave out fall back to their defaults.

curl -sS -X PATCH https://apis.kentro.live/pixel/v1/properties/$PROPERTY_ID \
  -H "Authorization: Bearer $KENTRO_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "settings": { "consent": { "requireForAnalytics": true, "requireForMarketing": true, "defaultWhenUnknown": "denied", "honorGpc": true }, "sensitivePathPatterns": ["/account", "/patients"] } }'
Event purposeState in the snapshotResult
analytics or marketinggrantedaccepted
analytics or marketingdeniedsuppressed
analytics or marketingunknowndefaultWhenUnknown when the purpose is required (suppressed by default); accepted when it is not
marketingany, with GPC and honorGpcsuppressed
functionaldeniedsuppressed
functionalgranted or unknownaccepted

An unknown marketing state is never treated as granted for exports: anything that needs marketing consent later (ad networks, marketing audiences and exports) still requires an explicit grant in the person's consent record.

What suppression means

A suppressed event is recorded with processing_status: suppressed_consent so that consent coverage can be measured. It is stored minimized: the event name, timestamps, the consent snapshot and a coarse context (referrer domain, device class, bot flag and locale), without properties, identifiers, references, page URL or page title. It never enters sessions, conversions, attribution, audiences or destination deliveries, and it does not use up its event_id.

When the snapshot states a choice (a purpose explicitly granted or denied, or an active GPC signal), the suppressed event also keeps the person keys the consent record is filed under. Kentro records the stated choices in the consent record, then removes those keys from the stored event.

Consent record

Kentro keeps a consent record per property for each person key: the anonymous id (anonymous), the signed-in subject reference (authenticated) and the commerce customer reference (commerce_customer). Audiences and destination deliveries check it at the time of use, on top of the decision taken at ingestion.

  • Only explicit choices are recorded: a purpose left unknown is not a choice, so a property default never becomes a decision.
  • Choices are ordered by the time Kentro received them; the recorded_at your banner sends is kept as evidence only. A GPC signal stays in force until a snapshot says gpc: false.
  • A consent_withdrawal privacy request records every purpose as denied. A later snapshot overrides it only when its choice was recorded after the withdrawal was received.
  • At use time, marketing needs an explicit grant (and no GPC signal where the property honors GPC); ad networks need an explicit marketing grant and no GPC signal at all; analytics follows the explicit state, else the property's rule; functional is allowed unless explicitly denied.

Sensitive-data quarantine

Before an event is stored, Kentro scans the string values of properties, the page title, the page path, UTM values, references and the form field values of lead events with four detectors:

DetectorMatches
health_termA maintained health vocabulary in three tiers, matched as whole words in any case (plurals included). Named conditions, medications, treatments and drug classes (for example diabetes, ozempic, chemotherapy) count in every string. Clinical words (for example diagnosis, prescription, treatment, patient, appointment, lab result) count in free text: page titles, URL paths, UTM values, references, search queries, reasons, notes and lead fields. Generic health words that also name ordinary retail products (for example medical, pharmacy, therapy, weight loss, GLP-1) count only on health-vertical properties; a GLP-1 page that names a drug (semaglutide) or, in free text, a clinical word (prescription) is still detected on every property.
icd10_codeICD-10 style codes with a decimal part, such as E11.9 or J45.909.
secretsk_live_ keys, AWS access key ids (AKIA...), PEM private keys or certificates and JWT-like tokens.
card_numberRuns of 13 to 19 digits (spaces or dashes allowed) that pass the Luhn check, except under id-like keys (such as order_id, sku or invoice_number) and pure-digit ids from server sources.
  • A hit quarantines the event: the status is quarantined with SENSITIVE_PAYLOAD, properties becomes { "quarantined": true }, the page title becomes [redacted], a matching page path is redacted and a matching UTM value or reference removed. Only the detector names are kept, and the event is never processed.
  • A payload too large or too deeply nested to scan completely (more than 2,000 strings or 12 levels) is quarantined as SENSITIVE_SCAN_INCOMPLETE.
  • Authoritative commerce events from your server are not quarantined: the matching fields are replaced by [redacted] (id-like fields by a stable redacted_ value), the order still counts as revenue, the result carries SENSITIVE_REDACTED, and the event is never forwarded to destinations.

Because page titles are scanned as free text, a page titled "Book an appointment" quarantines every page view on it. settings.privacy.healthVertical (true, false or null; null, the default, means on under strict privacy mode) widens the scan for health businesses: clinical words then count in every string, and the generic health words count too.

Sensitive path patterns

settings.sensitivePathPatterns lists the URL paths that carry personal or sensitive data, for example account, order or patient pages. In Kentro GO, set them in the property's Settings tab. What a match does depends on where the event comes from:

  • An event from a browser route is discarded whole. This applies to POST /v1/events, POST /v1/events/batch and the GIF beacon, when the page the event was sent from (context.page_url) matches, or when a marketing.page_viewed names a matching properties.page_path. Kentro keeps nothing of the event: no event record and no rejected-event sample. The request still answers 202, and the event's result is { "event_id": "...", "status": "rejected", "reason_code": "SENSITIVE_PATH" }. Ingestion health counts it in rejected. This check runs right after the envelope checks (format, size and clock skew) and before everything else, so an unknown name, a reserved name or a schema violation on such a page also answers SENSITIVE_PATH.
  • An event from the server route is kept, with the path redacted. A fact your backend records, such as a paid order, is never dropped because of a page address.
  • A matching path inside another event is redacted. A URL- or path-valued property that points at a matching page, for example the destination_url of a click on another page, is redacted and the event is kept.
PatternMatches
/accountThe path /account and everything under it (/account/orders/1001).
/patient/*/labs* as a whole segment matches exactly one segment: /patient/123/labs.
/order-** inside a segment matches any run of characters there: /order-1001.
**/reset-passwordA leading **/ matches at any depth: /en/account/reset-password.
  • Patterns start with / (or **/) and are at most 200 characters and 20 segments; a property can have up to 50. Matching is case-insensitive and also tries percent-decoded segments.
  • Redaction starts at the last segment of the matched part: /account/orders/1001 becomes /[redacted]/[redacted]/[redacted], and /patient/123/labs/today becomes /patient/123/[redacted]/[redacted].
  • Regular expressions are not accepted. A plain expression such as ^/account is converted when it is saved; anything else is refused with 400. A stored value that cannot be converted is read as /*, which matches every path that has a segment: until it is fixed, browser events from every page except the home page are discarded, and other events have every path redacted.
  • A saved change reaches every collector instance within about a minute.

Page view settings

settings.tracking.autoPageviews and settings.tracking.spaRoutes (both true by default) decide whether Kentro keeps the page views the browser SDK sends on its own. The SDK (1.4.0 and later) marks those page views with context.trigger: auto for the one it sends during init, spa for a route change. In Kentro GO, the property's Settings tab has the two switches: Record a page view when a page loads and Record a page view when a single-page app changes route.

SettingWhile it is false
settings.tracking.autoPageviewsA marketing.page_viewed with context.trigger auto is discarded.
settings.tracking.spaRoutesA marketing.page_viewed with context.trigger spa is discarded.
  • A discarded page view answers { "event_id": "...", "status": "rejected", "reason_code": "TRACKING_OFF" } in a 202 response. Kentro keeps nothing of it, not even a rejected-event sample; ingestion health counts it in rejected.
  • These settings never discard a page view without a trigger: your own page calls, page views your server sends, and page views from an SDK older than 1.4.0 (a browser can run the previous file for up to an hour after a release). marketing.session_started and every other event are kept whatever the two settings say.
  • The SDK options autoPageviews and spa decide what the browser sends; these settings decide what Kentro keeps. Changing a setting needs no change to the install snippet.
  • settings.tracking.clicks, forms, performance and errors are stored and returned, and have no effect: the SDK does not record clicks, form starts, performance timings or script errors.
  • A saved change reaches every collector instance within about a minute.

Form fields and lead details

Lead events (marketing.lead_captured and marketing.form_submitted) may carry properties.fields as an object of field values. The event record keeps only the field names (for form_submitted) and the hashed customer.email_sha256 and customer.phone_sha256; the values are scanned and then discarded. Only when settings.lead.rawEmail is true (default false; true for landing pages created by Kentro GO) and the event was accepted, the trimmed and format-checked email, name and phone are added to the person's Pixel record (the newest 20 submissions are kept), where a privacy deletion removes them.

settings.tracking.formFieldAllowlist limits which of those field values Kentro uses at all. It is a list of field names, matched whatever their case; in Kentro GO it is Lead form fields to keep on the property's Settings tab.

  • An empty list (the default) uses all of them.
  • Otherwise only the listed fields are hashed or kept: email, phone, and the name, either whole (name, which also covers first_name and last_name) or by part (first_name, last_name).
  • Other names have no effect, so a list that names none of these fields keeps no value.
  • The field names of marketing.form_submitted are recorded either way, and every value is still scanned by the detectors.
  • Identifiers you send yourself under properties.customer are not affected.

Privacy requests

Privacy requests cover one person across every identifier Kentro Pixel knows. All four routes need pixel:manage. In Kentro GO, the Pixel page's Privacy tab files and follows them.

curl -sS https://apis.kentro.live/pixel/v1/privacy/requests \
  -H "Authorization: Bearer $KENTRO_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "delete",
    "subjectKeys": [
      { "type": "email_sha256", "key": "[email protected]" },
      { "type": "anonymous_id", "key": "anon_6f1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e" }
    ]
  }'
FieldValues
typeexport, delete, anonymize or consent_withdrawal.
subjectKeys1 to 100 entries of { "type", "key" }. Types: anonymous_id, subject_ref, commerce_subject_ref, email_sha256, phone_sha256.

email_sha256 and phone_sha256 keys accept a SHA-256 hex digest or a raw email address or phone number; raw values are hashed on arrival (email trimmed and lower-cased; phone reduced to 7 to 15 digits) and discarded. Other keys are 1 to 256 characters. An unusable key answers 400 INVALID_SUBJECT_KEY.

{
  "id": "0192f0c9-4d5e-7f60-8172-8c9d0e1f2a3b",
  "type": "delete",
  "subjectKeys": [
    { "type": "email_sha256", "key": "8c87b489ce35cf2e2f39f80e282cb2e804932a56a213983eeeb428407d43b52d" },
    { "type": "anonymous_id", "key": "anon_6f1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e" }
  ],
  "status": "received",
  "requestedBy": "7d1f2e3a-4b5c-4d6e-8f90-1a2b3c4d5e6f",
  "verification": { "requestedVia": "pixel-api", "requestedBy": "7d1f2e3a-4b5c-4d6e-8f90-1a2b3c4d5e6f", "requestedAt": "2026-10-09T18:00:00.000Z", "subjectKeyCount": 2, "hashedFromRaw": 1 },
  "result": null,
  "resumable": false,
  "createdAt": "2026-10-09T18:00:00.000Z",
  "completedAt": null,
  "jobId": "0192f0c9-4d5f-7a71-9283-9d0e1f2a3b4c"
}

Requests run asynchronously. Follow one with GET /v1/privacy/requests/:id or list them with GET /v1/privacy/requests?status&type&limit&cursor. Statuses are received, verifying, processing, completed and failed.

TypeResult
exportA JSON export of the person's Pixel data; result.url is a download link valid for 24 hours (result.expiresAt; a very large export comes in result.parts). Besides the stored events (events), it holds the person's events that are still waiting to be processed, or that could not be processed, in a section named unprocessed_events.
deleteThe person's events are removed from the event history and from the processing queue; sessions, touchpoints and consent history are removed; conversions are unlinked; audience memberships are ended (the next webhook sync reports the leave as deleted); queued deliveries are cancelled; and the destination answers stored with their event deliveries are replaced by a marker.
anonymizeIdentifying data is erased from the person's events, in the event history and in the processing queue, and the destination answers stored with their event deliveries are replaced by a marker. Consent history is removed, audience memberships are ended and queued deliveries are cancelled. The sessions, touchpoints and conversions that feed reports are kept under a new pseudonymous key.
consent_withdrawalEvery purpose is recorded as denied, queued deliveries are cancelled and audience memberships are ended. Events in the processing queue and stored destination answers are left as they are.
  • A request covers exactly one person. A device the person shared with someone else is listed in result.sharedDevices for your review, and only the requester's own records on it are touched.
  • Hashed email and phone keys also match retained lead records.
  • A very large request stops after 50,000 events in one run and is recorded failed with result.partial: true and "resumable": true; Kentro retries it automatically. If it is still failed after the automatic retries, POST /v1/privacy/requests/:id/resume queues it again (202). That route answers 409 NOT_RESUMABLE for a request that is completed, failed for good or still processing, and 409 PRIVACY_JOB_ACTIVE while a run is queued or running.

What a delete or anonymize request erases

Besides the event history and the records listed above, a delete or anonymize request covers two places where a person's identifiers can remain: the processing queue and the answers stored with deliveries.

Events in the processing queue. An accepted event waits in a queue until the background processor handles it, and an event that could not be processed stays there (see Retention). The request covers the person's events in that queue, whatever their state:

  • delete removes them.
  • anonymize rewrites each one the way it rewrites a stored event, and removes the person's identifiers from the stored error text of a failed one. A waiting event is still processed afterwards, as an anonymous event.

Stored destination answers. Every delivery keeps what the destination answered in response. For a webhook that is the first 1,024 characters your endpoint returned, which can repeat the person's identifiers when the endpoint echoes its input. For every delivery of the person's events, in any status, response becomes:

{ "erased": true, "reason": "privacy_request" }

A validate-only delivery keeps "validateOnly": true next to the two fields. The delivery's status, attempts, providerReceipt, error and timestamps do not change, and a delivery without a stored answer is left alone.

An export reads the same queue: the unprocessed_events section lists the person's events found there. Each entry has the fields of an entry in events, plus status: pending (waiting), failed (could not be processed) or done. An event that failed after it reached the event history appears in both sections. An export changes nothing.

Not covered:

  • Deliveries of audience membership. They carry a page of members, not one person's event, so a privacy request does not cancel a queued one or replace its stored answer. A page is built when it is sent, so a person deleted in the meantime is left out of it. A webhook endpoint that echoes the membership payload leaves subject keys in response until the delivery history expires (30 days).
  • The error text of a delivery. It is never rewritten, on any delivery. It holds Kentro's own message or the provider's error message; for a webhook it names only the status your endpoint answered, never the body.

result.counts of the request reports what was done, next to the counts of events, sessions and deliveries:

CountRequest typeMeaning
unprocessedEventsexportEvents from the processing queue in the unprocessed_events section.
unprocessedEventsDeleteddeleteEvents removed from the processing queue.
unprocessedEventsAnonymizedanonymizeEvents rewritten in the processing queue.
deliveryResponsesEraseddelete, anonymizeDeliveries whose stored answer was replaced by the marker. A delivery without a stored answer, or one already replaced, is not counted.
unprocessedEventsUnreadableexport, delete, anonymizePresent only when above zero: entries of the queue whose event could not be read, so Kentro could not tell whose they are. They are left unchanged and are not exported. Contact [email protected] when you see this count.

Limits with external providers

Kentro cannot recall data that a destination already received. When a request is completed, result.destinations lists every destination that is enabled or has delivered before, each with irreversible: true and what to do:

DestinationWhat to do
Meta Conversions APIRequest deletion through Meta Business tools (a data deletion request for the dataset).
Google Ads offline conversionsUploaded conversions cannot be deleted by Kentro, and a retraction only adjusts reporting; use the Google Ads account data controls.
GA4 Measurement ProtocolUse GA4 user deletion (Admin or the User Deletion API).
WebhookPayloads already delivered are under the receiving system; notify its owner.

A privacy request does not touch the person's browser. An explicit denial through consentChanged deletes what the SDK stored on that device, and reset forgets everything the SDK stored.