Fictura
Privacy

Privacy

What the SDK collects, where Fictura keeps it, which services it is sent to, and the controls for deleting, exporting and limiting it.

This page describes what the code does. It is not a legal document and makes no compliance claims. For a data processing agreement (DPA), contact us.

What the SDK collects

Identifiers

IdentifierWhere it comes from
Device idiOS: a random UUID kept in the Keychain, so it survives a reinstall. Android: the app-scoped Android ID (SSAID). Your app can supply its own with getDeviceId.
Account idYour getAccountId, or the id passed to Growth.identify().
RevenueCat idYour getRevenueCatId, used to join billing webhooks to the same person.
Session idA UUID v7 sent as $session_id. It rotates after 30 idle minutes or 24 hours.
Install idA random UUID in normal app storage, deleted on uninstall. With the device id it tells a reinstall from a new install. Latest SDK.
Ad idsThe IDFA only when the app already has ATT permission (the SDK never shows the prompt), and the GAID on Android. Used for exact matching and conversion APIs. Latest SDK.

Events sent automatically

  • first_open and app_open, including the URL the app was opened with.
  • app_backgrounded, with time in the foreground, and app_updated.
  • Screens: screen_viewed and screen_closed.
  • Taps: element_tapped, rage_tap and dead_tap. A tap records the element, its component and position, and its own text ($el_text, up to 100 characters). Text inside a text input is never read. Add fictura-no-capture to an element to drop its taps entirely, or fictura-no-text to keep the tap without its text, and use beforeSend to edit or drop any event before it is sent. The lifecycle, screen and tap events can be switched off from the dashboard.
  • Errors: crashes and unhandled promise rejections, with message, stack, current screen and account id. console.error and console.warn lines are kept as breadcrumbs on the next real error; a console.error line is sent as an error of its own only when it is passed an Error object or you set captureConsoleErrors: true. On by default; switch it off with enableErrorCapture: false in Growth.init.

Context on every event: SDK name and version, OS and version, device type, model and manufacturer, app version, build and bundle id, locale, time zone, screen size, emulator flag and network type. Each batch also carries platform, app version and the device's region setting (locale_region), which is informational only.

Also sent: push tokens, if you register for push; UTM parameters from deep links; attribution signals on first launch (the Play and Meta install referrers on Android, the AdServices token, an fct_ clipboard token when one is present, and a custom product page id on iOS); performance traces (app start, screen loads, and each fetch or XMLHttpRequest with its method, status, timing and URL without the query string). Tracing is on by default; switch it off with enableTracing: false.

The SDK never reads or sends the device's IP address itself, and it has no session replay or screenshot capture.

Backend SDKs

A backend SDK runs on your server, so it can see more than an app can. This is what the Python SDK sends, and how to limit it. What your code logs and holds in variables is your call, and it may include personal data.

DataWhat is sentTurn it off or narrow it
Local variablesWith an error: variable values in your own frames and the newest 5 frames, as a short repr. At most 30 a frame and 200 characters a value.capture_locals=False
Source linesWith an error: 5 lines of your code around each frame.include_source_context=False
RequestWith an error: URL, full query string, method, and headers.event_scrubber, before_send
Request bodyWith an error: JSON or form bodies, up to 10,000 bytes by default.capture_body=False, or max_request_body_size="never"
Client detailsWith an error: browser or app, OS and device from User-Agent, and country from the cf-ipcountry header if your CDN sets it.before_send
BreadcrumbsWith an error: up to 100 recent log lines and HTTP calls.breadcrumbs=False, before_breadcrumb
LogsOn by default with fictura.init from 0.4: lines at INFO and above, each with its message, logger, attributes, route, user id, trace and release.enable_logs=False, logs_level, before_send_log

Cookies, IP addresses and uploaded files are never sent.

Before anything leaves your server, the SDK replaces values whose key looks sensitive (password, secret, token, api_key, auth, cookie, session, csrf, jwt, credit_card and similar) in variables, headers, bodies and query strings, and masks strings that look like keys or card numbers. This works on key names and common patterns, so it can't catch everything: a person's email in a variable called name is sent. Use before_send and before_send_log to remove anything else, and event_scrubber to change the list.

Log lines are stored for 14 days and then dropped. Error events follow the retention set in Issue settings.

Where it is stored

  • Database. The hosted service runs on Railway. Events, people and revenue rows are stored in a Supabase Postgres database. The region is set by the deployment, not in the code; contact us to ask which region the hosted service uses.
  • Files. Screenshots attached to support requests sit in a private Supabase Storage bucket and are read through 30-minute signed links. Bulk exports are written to an exports bucket and handed out the same way.
  • Your own Supabase. Fictura does not create a project in your Supabase organisation: the App backend section is gone from Setup. Fictura's analytics data is not stored there.

IP addresses

  • Events. No raw IP is stored. The server hashes the request IP (SHA-256, cut to 16 hex characters). The hash is used only for modelled matches on Android and web; iOS installs are never matched by IP. Country is looked up from the IP on the server.
  • Bio-link visits (/t/…). The full IP, user agent, forwarding chain and Accept-Language are kept for 30 days and then cleared. A truncated IP (/24 or /64) is kept. Country is looked up from the IP with ip-api.com.
  • Dashboard sign-ins. Your team's session IPs and an approximate location (from ip-api.com) are kept so you can review active sessions.

Settings → Privacy → Discard IP addresses turns off the event IP hash and country lookup for an app.

Services the code sends data to

Only when you connect them

ServiceWhat it receives
PostHogEach new event, mirrored to your project.
Outgoing webhookBilling, error, uptime, experiment and insight alert events, as described on Webhooks, plus audience membership changes when cohort sync is on.
Slack, Resend (email)Alert text.
Linear, JiraAn error issue's details, when you turn it into a ticket.
Expo push, OneSignalPush tokens and the message, when you send a push.
AnthropicYour questions to Hawkings, and the analytics results its tools return. Runs on your own key, or Fictura's on plans that include AI.
Stripe, RevenueCat, App Store ConnectReads and checkout calls using your credentials.
Meta, TikTok, Google Ads, Snapchat, Reddit, Apple AdsSpend reads and campaign changes.
Meta, Google Ads, Snapchat, TikTok, Pinterest (conversion APIs)Install, trial and purchase events, with the IDFA or GAID only when the person allowed it and EEA consent flags passed through. Off until you save credentials. See Conversion APIs.
Apple (AdServices)The AdServices attribution token from a new iOS install, to get its Apple Ads campaign. See Apple Ads.
Google Search Console, Google Cloud billing, Postiz, Appfigures, AppsFlyerRead-only.
Amazon S3Your events, when you add an S3 destination.

Always

  • Supabase (database, authentication, storage) and Railway (hosting).
  • ip-api.com, for the bio-link visit and dashboard sign-in lookups above.
  • Resend and Stripe on Fictura's own account, for email to your team and your Fictura bill.
  • Telegram, for operational alerts to the Fictura team.

Controls

ControlWhere
Delete a personUser page → Delete user, or DELETE /api/v1/users/:id.
Export a personUser page → Export JSON, or GET /api/v1/users/:id/export.
Discard IP addressesSettings → Privacy, per app.
Redact personal dataSettings → Privacy: emails, phone numbers and IP addresses in string property values become [redacted].
Property deny-listSettings → Privacy: property keys dropped at ingest.
Drop or edit events on deviceSDK beforeSend, sanitizeProperties, fictura-no-capture, fictura-no-text.
Switch event types offCapture control.
Opt-outGrowth.optOut() / Growth.optIn() / Growth.isOptedOut() and the defaultOptIn setting, from SDK 0.22.0. Opting out empties the queue and stops all capture and writes. The reads the app needs to work (config, paywall pages) still run.

The three Privacy settings apply to events received after you save. Events already stored are not rewritten.

What deletion does

Deleting a person removes their events, identifiers, revenue rows, experiment assignments, sessions, attributes, push tokens and log lines. It returns a count for each.

Every identifier the person had (device id, account id, RevenueCat id) is then suppressed. Events and billing webhooks that carry a suppressed identifier are dropped at ingest and counted as a suppressed_identifier ingest warning, so a deleted person is not rebuilt by the next batch from their phone. Deleting twice is safe: the second call finds nothing.

Every deletion and export is recorded with its counts.

Newer backends only

Person deletion and export, suppression and the three Privacy settings are part of a recent backend release. On a Fictura backend without them, the dashboard hides the matching buttons and settings.

iOS privacy manifest

Apple asks every app to declare, in a privacy manifest, the data it and its SDKs collect. @fictura/sdk is JavaScript only, so it ships no PrivacyInfo.xcprivacy of its own; the entries belong in your app's manifest.

From SDK 0.22.0, the @fictura/sdk/plugin Expo config plugin writes these entries for you:

app.json
{
  "expo": {
    "plugins": ["@fictura/sdk/plugin"]
  }
}

With any SDK version, you can declare the same entries yourself through Expo's ios.privacyManifests:

app.json
{
  "expo": {
    "ios": {
      "privacyManifests": {
        "NSPrivacyTracking": false,
        "NSPrivacyCollectedDataTypes": [
          {
            "NSPrivacyCollectedDataType": "NSPrivacyCollectedDataTypeDeviceID",
            "NSPrivacyCollectedDataTypeLinked": true,
            "NSPrivacyCollectedDataTypeTracking": false,
            "NSPrivacyCollectedDataTypePurposes": ["NSPrivacyCollectedDataTypePurposeAnalytics", "NSPrivacyCollectedDataTypePurposeAppFunctionality"]
          },
          {
            "NSPrivacyCollectedDataType": "NSPrivacyCollectedDataTypeProductInteraction",
            "NSPrivacyCollectedDataTypeLinked": true,
            "NSPrivacyCollectedDataTypeTracking": false,
            "NSPrivacyCollectedDataTypePurposes": ["NSPrivacyCollectedDataTypePurposeAnalytics"]
          },
          {
            "NSPrivacyCollectedDataType": "NSPrivacyCollectedDataTypePurchaseHistory",
            "NSPrivacyCollectedDataTypeLinked": true,
            "NSPrivacyCollectedDataTypeTracking": false,
            "NSPrivacyCollectedDataTypePurposes": ["NSPrivacyCollectedDataTypePurposeAnalytics", "NSPrivacyCollectedDataTypePurposeAppFunctionality"]
          },
          {
            "NSPrivacyCollectedDataType": "NSPrivacyCollectedDataTypeCrashData",
            "NSPrivacyCollectedDataTypeLinked": true,
            "NSPrivacyCollectedDataTypeTracking": false,
            "NSPrivacyCollectedDataTypePurposes": ["NSPrivacyCollectedDataTypePurposeAppFunctionality"]
          }
        ]
      }
    }
  }
}

Leave out Crash Data if you switch error capture off. Purchase History applies when billing events reach Fictura through RevenueCat, Stripe or purchase_completed events. The native modules the SDK uses (such as expo-secure-store and expo-application) declare their own required-reason APIs in their own manifests.

Expo applies ios.privacyManifests when it generates the native project. Without that step, edit PrivacyInfo.xcprivacy in Xcode instead. See Expo's Privacy manifests guide and Apple's Describing data use in privacy manifests.

On this page