Security Whitepaper · v1.3 · April 2026

Screenpipe Security Architecture

Local-first data architecture. Source-available Rust capture engine. On-premise AI options. Enterprise policy controls. Source-linked review paths for privacy-sensitive deployments.

verify our security claims

Don't trust us. Audit the code yourself, or ask AI to review our security architecture against the open source repository.

security audit prompt

Paste this into any AI chat to get a security review of our codebase. Works with ChatGPT, Claude, Gemini, or any LLM with web access.

deployment modes

Local-first does not mean one data path.

Screenpipe can run as a personal assistant or a scoped team deployment. The important question for buyers is not a slogan; it is which data flow they approve.

Local-only

What stays local
Screen capture, accessibility text, OCR output, audio files, transcripts, and the local database.
What may leave the device
Nothing is required to leave the device for core capture and search.
Buyer decision
Best for self-serve use, regulated pilots, and proving value before any cloud path is enabled.

Local + optional cloud AI

What stays local
The raw capture store remains on the endpoint unless the user or organization enables export or sync.
What may leave the device
Selected prompts, summaries, or context snippets may be sent to the chosen AI provider or confidential route.
Buyer decision
Buyer chooses model, provider, retention posture, redaction, and whether local models are required.

Team / enterprise

What stays local
Endpoint capture and local history can stay on managed devices under admin policy.
What may leave the device
Team reports, sync, admin workflows, exports, connectors, and agent outputs depend on deployment scope.
Buyer decision
Buyer defines consent, retention, employee controls, report contents, and admin visibility.

1. Security Model

Screenpipe is local-first by design. All screen captures, audio transcriptions, and metadata can be processed and stored on the user's device for core local-mode use. Optional sync, cloud AI, connector, export, and team workflows should be scoped per deployment. The capture engine is written in Rust (13 crates), providing compile-time memory safety — eliminating buffer overflows, use-after-free, and data races that affect C/C++ recording tools.

Core Principles

Local-First

Core capture and search can store data on the user's device. SQLite + media files at ~/.screenpipe/. Optional cloud, sync, AI, and team paths are deployment choices.

Source Available

The capture, encryption, and access-control code is available for independent review.

Memory-Safe Engine

13 Rust crates. No GC overhead. Compile-time safety eliminates entire vulnerability classes (buffer overflows, use-after-free, data races).

Admin-Controlled

Enterprise admins lock settings, hide UI, push content filters, and control AI providers across all devices via MDM/Intune.

System Architecture

screenpipe-engine

main server, HTTP API on 127.0.0.1:3030 (localhost only), token-authenticated

Vision Manager

Audio Manager

Scheduled Manager

Sync Service

API Routes

screenpipe-screen

SCK/WGC · OCR/A11y

screenpipe-audio

CPAL/PA · VAD/STT speaker diarize

screenpipe-core

scheduled · sync · crypto PII · permissions

screenpipe-vault

at-rest encryption ChaCha20 · Argon2id

screenpipe-db

SQLite, FTS5 88 migrations

screenpipe-a11y

tree walker · UI events

screenpipe-events

shared types across crates

All 13 crates compile to a single binary. Everything runs on-device.

API & Network Security

Localhost Binding

The HTTP API binds to 127.0.0.1 by default. Other devices on the network cannot reach the API. Configurable to 0.0.0.0 for multi-device setups (requires explicit opt-in).

Token Authentication

All API requests require a Bearer token (auto-generated on first launch, stored in the encrypted settings store with OS keychain encryption). No localhost bypass — even local processes must authenticate.

Cookie + Header + Query

Auth supports Bearer header (fetch), HttpOnly cookie (img/WebSocket), and ?token= query param. The Tauri app sets the cookie automatically on init.

CORS Restriction

Cross-origin requests are restricted to localhost, 127.0.0.1, and tauri:// origins. Malicious websites cannot make requests to the local API.

Content Security Policy

Strict CSP on the Tauri webview: script-src 'self', restricted connect-src, frame-src, and img-src. Prevents XSS and unauthorized resource loading.

HTTPS-Only Scheduled Tasks

Scheduled task installation over plain HTTP is rejected. Only https:// sources are accepted, preventing MITM attacks during download.

Exempt endpoints (no auth required): /health, /ws/health, /connections/oauth/callback. Run screenpipe auth token to view your API key.

Credential Storage

All secrets (OAuth tokens, API keys, session data) are stored in a unified secrets table in the local SQLite database, encrypted with AES-256-GCM. The encryption key is stored in the OS keychain (macOS Keychain / Windows Credential Manager). No plaintext credential files.

Secret Store

AES-256-GCM encrypted in SQLite secrets table

Key Storage

OS Keychain (macOS / Windows / Linux)

Migration

Legacy files auto-migrated to encrypted store on startup

2. Vision Pipeline Architecture

The vision pipeline uses an event-driven capture model — not continuous polling. Captures are triggered by user activity (app switch, click, typing pause, scroll stop, clipboard change) or visual change detection (histogram diff > 5%). This reduces resource usage while maintaining complete coverage. event_driven_capture.rs

Vision Pipeline — Event-Driven Capture

Trigger Detection

App switch · Window focus · Click · Typing pause · Scroll stop · Clipboard change · Visual change (>5% diff) · Idle (30s). Debounce: min 200ms.

Guard Checks

Screen locked? · DRM content? · Outside work-hours? · Ignored window? · Content hash unchanged? → Skip (unless >30s since last write)

Screenshot Capture

async

macOS: ScreenCaptureKit · Windows: WGC · Linux: xcap

1. Exclude filtered windows

2. Full-screen capture

3. Black frame → skip

4. Write JPEG to ~/.screenpipe/data/

Accessibility Tree Walk

spawn_blocking

macOS: AX APIs (cidre) · Windows: UI Automation · Linux: AT-SPI2 D-Bus

1. Walk focused window

2. Extract all text nodes

3. Browser URL detection

4. Compute content hash

5. Adaptive budget per app

OCR (conditional)

IF no a11y text → run OCR · IF terminal app → always OCR · IF a11y text "thin" (canvas apps, meetings) → OCR + a11y (hybrid) · ELSE → a11y text only

Engines: macOS Vision.framework · Windows OCR API · Linux Tesseract. Semaphore: 1 concurrent. Cache: per window+hash, 5 min.

PII Removal (if enabled) — 27 regex patterns

Database Insert

frames table + ocr_text (if OCR ran) + elements (a11y nodes) + element dedup (ref prev frame) + FTS5 index update → hot_frame_cache (in-memory)

Sources: event_driven_capture.rs · paired_capture.rs · vision_manager · apple.rs (OCR) · a11y/tree

3. Audio Pipeline Architecture

The audio pipeline captures from multiple devices simultaneously, processes 30-second segments with 2-second overlap, runs voice activity detection, speaker diarization, and transcription — all on-device. audio_manager

Audio Pipeline — Capture to Storage

Audio Capture

OS audio devices (mic + system audio, per-device streams). macOS/Windows: CPAL · Linux: PulseAudio. broadcast::channel (1000 sample capacity).

Recording Loop

30-second segments + 2-second overlap. SourceBuffer: Bluetooth packet loss detection, silence insertion (max 500ms — prevents Whisper hallucinations). Flush to crossbeam::channel (capacity 256).

Realtime Mode

Transcribe immediately after capture. Default for normal usage.

Batch Mode

Defer during meetings (Zoom, Teams). Persist audio to disk first. Reconcile and transcribe when meeting ends.

Audio Processing

1. Resample to 16kHz · 2. Normalize + music filtering · 3. VAD (Silero / WebRtc) — 512-sample chunks (Win) / 1600 (macOS). Speech threshold: 0.5 (input), 0.15 (output). Spectral noise subtraction. Min speech ratio: 2% → skip if below.

Speaker Diarization (on-device)

1. Pyannote v3.0 segmentation (ONNX, 10s windows) → speech/silence boundaries · 2. WeSpeaker CAM++ embedding (ONNX) → 192-dim fingerprint · 3. Cosine similarity matching (threshold: 0.9) → assign or create speaker · 4. Calendar-assisted: seed known speakers, constrain max during meetings.

Transcription

Local (no network): Parakeet MLX · Whisper Large v3 Turbo · Whisper Large v3 · Qwen3 ASR · OpenAI-compatible endpoint. Cloud (opt-in): Deepgram API. RMS energy check: skip if <0.015. Per-device overlap dedup.

Database Insert

audio_chunks + audio_transcriptions tables. Speaker ID → speakers table (embedding centroid). PII removal (optional) · FTS5 index update.

Sources: recording loop · VAD · segmentation · embedding · transcription engine

4. Cryptography

All cryptographic primitives use audited libraries. Parameters are from source: crypto.rs and team-crypto.ts.

ComponentAlgorithmParameters
Data EncryptionChaCha20-Poly1305256-bit key, 96-bit nonce, AEAD auth tag
Key DerivationArgon2id v0x1364 MB memory, 3 iterations, parallelism 4, 256-bit output, 256-bit salt
Searchable EncryptionHMAC-SHA256256-bit output, normalized keywords (lowercase, trimmed, deduped)
Data IntegritySHA-256Post-decryption verification checksum
At-Rest VaultChaCha20-Poly1305 + Argon2idPassword-derived keys, lock/unlock via screenpipe-vault crate
Team Config EncryptionAES-256-GCM96-bit random nonce per operation (Web Crypto API)
Team Key WrappingPBKDF2 + AES-256-GCM600,000 iterations, SHA-256, 128-bit salt
Credential StorageTauri Secure StoreOS keychain (macOS Keychain, Windows Credential Manager)

Zero-Knowledge Key Hierarchy

Password + Salt

▼ Argon2id (64MB, 3 iter, p=4)

Password Key

▼ Decrypts

Encrypted Master Key

stored on server, never in plaintext

Data Key

ChaCha20-Poly1305

Encrypts blobs (OCR, audio, frames)

Search Key

HMAC-SHA256

Search tokens — server matches without seeing plaintext

Source: crypto.rs · screenpipe-vault

5. Data Controls & PII Protection

Capture Controls

ControlDetails
Window FilteringExclude specific apps from capture (e.g., 1Password, banking). Admin-pushable include/exclude lists. Incognito window auto-detection (Safari, Chrome, Firefox).
URL FilteringExclude specific websites and URL patterns from capture.
Audio Device SelectionEnable/disable per device. Select specific microphones and system audio sources.
Monitor SelectionChoose which displays to record. Exclude specific monitors. Dynamic monitor connect/disconnect handling.
Data RetentionAuto-delete data older than 1–90 days (configurable, min 1 day enforced). Batch deletion in 1-hour windows. Disk reclaim via PRAGMA incremental_vacuum. Runs every 5 minutes.
DRM Content DetectionPauses all capture when DRM apps are focused. 11 streaming services (Netflix, Disney+, Hulu, Prime Video, Apple TV+, Peacock, Paramount+, HBO Max, Crunchyroll, DAZN), 10 domains, URL path detection for Amazon Video. Browser detection across 15+ browsers via Accessibility API.

Sources: retention.rs · drm_detector.rs

PII Detection Engine

Regex-based PII detection engine with 27 pattern categories. Uses RegexSet for single-pass detection. No ML — deterministic, auditable pattern matching. pii_removal.rs

CategoryPatterns
FinancialCredit card numbers (4-digit groups), IBAN (ISO 13616)
Government IDsUS Social Security Numbers (XXX-XX-XXXX)
Contact InfoEmail (RFC 5322), formatted phone numbers (with country code), IPv4 addresses
CredentialsJWTs, PEM private keys, database connection strings (7 DB types), Bearer tokens, password fields, env var secrets
Service API KeysAWS (AKIA + secrets), GCP, Azure, GitHub, OpenAI (sk-proj/sk-), Anthropic (sk-ant-), Stripe (sk_live/sk_test), Slack (xoxb/xoxp), Discord, GitLab, NPM, PyPI, DigitalOcean, Telegram, Twilio, SendGrid, Mailchimp
SecretsBIP39 seed phrases (12–24 words), 2FA backup codes, password context fields, password UI indicators

Scheduled Task Permission System

Each scheduled task runs with configurable access controls. Evaluation order: Deny → Allow → Default → Reject. Deny rules always take precedence. permissions.rs

Rule TypeDescription
Api(METHOD /path)HTTP endpoint access control. Reader preset: 14 safe endpoints. Writer: +7 mutation endpoints.
App(name)Filter by application name (case-insensitive substring).
Window(glob)Filter by window title (glob patterns with * and ?).
Content(type)Restrict to content types: ocr, audio, input, accessibility.
Time & DayRestrict execution to hours (HH:MM-HH:MM, midnight wrap) and weekdays.
Offline ModeBlocks all non-localhost outbound network requests from scheduled tasks.
HTTPS-Only InstallScheduled task installation from http:// URLs is rejected. Only https:// sources accepted to prevent MITM attacks.

6. Speaker Identification

Screenpipe includes on-device speaker diarization — all processing runs locally with no cloud dependency:

ComponentDetails
Segmentation ModelPyannote v3.0 (segmentation-3.0.onnx) — speaker activity detection on 10-second windows, runs via ONNX Runtime on-device
Speaker EmbeddingsWeSpeaker CAM++ (wespeaker_en_voxceleb_CAM++.onnx) — 192-dimensional voice fingerprint per segment via filterbank features
Matching AlgorithmCosine similarity with configurable threshold (default: 0.9). Embeddings stored locally in SQLite. At capacity: force-merge to closest speaker.
Calendar IntegrationCalendar-assisted diarization seeds known speakers from meeting attendees, constrains max speakers during active meetings for improved accuracy.

Sources: embedding_manager.rs · embedding.rs · calendar_speaker_id.rs

7. Enterprise Deployment

FeatureDetails
Admin PolicyLock settings, hide UI sections (chat, timeline, settings). "Managed by [Org]" overlay. Policies sync every 5 min with offline fallback. Enterprise policy via Tauri command layer.
MDM DeploymentDeploy via Kandji, Intune, or any MDM. Reads enterprise.json from managed directory. Auto-updates disabled for IT control.
License ManagementSeat-based licensing with feature matrix. Cached 4 hours, 14-day offline grace period.
Write-Only ArchiveDevices write capture batches to your own S3 bucket with put-only credentials. No Screenpipe credential can read it; the denial is verified by a canary before the deployment is marked active.
Query Gateway PolicyEd25519-signed access policy issued by our control plane. Cached 1 hour (3600s), refreshed every 5 minutes (300s). Past the window every scoped v1 route returns 503 — fails closed, never open.
Gateway Token VerificationThe policy carries per-token SHA-256 verifier digests, never tokens. 256-bit token entropy makes the digest a one-way verifier of a full-entropy secret.
Gateway Clock Skew±5 minutes tolerance against the policy's signed issued_at. Larger skew is reported as E_POLICY_CLOCK_SKEW with the measured delta, so a wrong local clock is not misread as a Screenpipe outage.
Team Config EncryptionAES-256-GCM. Key generated on admin device, never sent to server. Shared via passphrase-protected invite (PBKDF2, 600K iterations).
Controlled UIHide chat, timeline, settings per device. Control AI models, transcription engines, scheduled task execution, data types.
Content Filter PushPush window/URL filters to all devices. Team filters are additive and cannot be removed by members.
API AuthenticationNon-localhost requests require Bearer token. Configurable api_auth and api_key per deployment.

Sources: use-enterprise-policy.ts · enterprise-license-prompt.tsx · policy.rs

MDM Configuration

// Pushed by MDM to: <app_dir>/enterprise.json
// Or manually at: ~/.screenpipe/enterprise.json
// macOS also checks: ../Resources/enterprise.json
{
  "license_key": "your-enterprise-license-key"
}

Write-Only Archive & Query Gateway

In a write-only archive deployment, devices write capture batches to your own S3 bucket using put-only credentials. Nothing reads that bucket except a query gateway you run on your own infrastructure. Screenpipe servers never hold your capture data. The gateway does, however, answer one question on every request — is this bearer token still authorized? — and it answers from an Ed25519-signed access policy issued by our control plane. That policy has a lifetime, and it is the one place where your archive availability depends on us.

PropertyValue and what it means
Validity window3600s (1 hour). A fetched policy is honored for one hour after the control plane issued it.
Refresh cadence300s (5 minutes). Revoke a token in the dashboard and it loses gateway access within 5 minutes — revocation is absence from the next policy pull, not a push.
Failure margin3600 / 300 = 12 refresh attempts per window. The 12th lands as the policy expires, so the gateway survives 11 consecutive failed refreshes (55 minutes) before any query is affected.
Past the windowFails closed. Every scoped /api/enterprise/v1/* route returns 503. It never degrades to serving an expired grant list, because a stale policy cannot prove a token has not been revoked since.
Clock-skew tolerance±300s against the policy's signed issued_at. Worst case before a cached policy is refused is therefore 3900s, not 3600s — robustness against a slightly wrong clock, not availability budget.
Token material in the policyPer-token SHA-256 verifier digests only, never tokens. Tokens are 256 bits of entropy, so the digest is a one-way verifier of a full-entropy secret; recovering one is a preimage attack with no dictionary to walk.

Telling clock skew apart from an outage

The policy timestamps are stamped by our clock and evaluated against your gateway clock, so disagreement between them has two distinct failure modes and both are yours to fix. A gateway clock more than 5 minutes ahead of ours treats a freshly delivered policy as already expired and returns 503 on every query while we are perfectly healthy — a phantom outage. A gateway clock more than 5 minutes behind ours is the security-relevant direction: policies look not-yet-valid, and a revoked token survives that much longer than the stated 5-minute revocation latency. Either way the fix is NTP on the gateway host, so the gateway names the cause in the 503 body rather than letting a local clock problem present as a Screenpipe outage:

503 body containsCause and owner
no policy loaded yetThe gateway has not completed a first successful policy fetch.
cached policy is past its validity windowGenuine refresh failure — the gateway could not reach us for over an hour.
clock disagreed with the signed issued_atYour clock, not our availability. The message carries the measured delta. Fix NTP on the gateway host.
policy is not yet validYour clock is behind ours beyond tolerance. Security-relevant: a revoked token also survives longer than the stated 5-minute latency.

Skew beyond tolerance is also logged with the fault code E_POLICY_CLOCK_SKEW, alongside E_POLICY_FETCH, E_POLICY_REJECTED and E_POLICY_STALE for the other policy failures.

Bearer verification is opt-in

Everything above applies only when the operator pins the policy signer public key via SCREENPIPE_GATEWAY_POLICY_PUBKEY_B64. With no pinned key the gateway serves the entire v1 query surface unauthenticated and warns loudly at startup — a posture that is only acceptable on an isolated network. Read the guarantees above as describing a configured deployment, not a default.

What a Screenpipe shut-off can and cannot do

Stated plainly, because your security team should read it from us rather than discover it. Seat enforcement happens at the policy issuer. If your subscription lapses, or we suspend your account, our control plane stops issuing policies. Your gateway serves from cache for the remainder of its window and then fails closed. Within at most 65 minutes, your own bucket becomes unqueryable through our software. No gateway configuration prevents that, because a gateway without a valid signed policy cannot prove any token is still authorized.

What a shut-off does not touch:

  • Your bucket stays yours. The objects sit in your own S3 account. We never held credentials that could read it, and that denial is canary-verified before a deployment is activated.
  • The archive format is plain. Batches are newline-delimited JSON. Any S3 client and any JSON tool reads them with your credentials and zero Screenpipe components involved. You lose our query layer over your data, not the data.
  • Capture keeps working. Local capture and the write path to your bucket do not depend on the gateway or on a policy.
  • The trust anchor is verifiable out of band. Pin the signing public key in your own config management and diff it on every deploy. That buys integrity, not availability: we cannot silently swap the key or forge a grant list. It does not extend the window — nothing does.

If an hour of coupling to our availability is not acceptable for your use case, raise it during evaluation. It is a real constraint of this architecture, not an oversight.

8. Network Requests

Core functionality requires zero network requests. Capture, OCR, local transcription, search, and scheduled tasks all run offline. Network requests occur only for explicitly enabled optional features:

FeatureDestinationData Transmitted
Cloud TranscriptionDeepgram APIAudio chunks (opt-in, admin-disableable)
Cloud AI (Scheduled)Screenpipe Cloud (ZDR or Confidential)Prompts + context. Most models run with zero data retention; select models run inside hardware enclaves where Screenpipe cannot read the data — see §9.
OAuth ConnectionsGoogle, Notion, etc.Tokens stored locally, data fetched to device only
AnalyticsPostHog (eu.i.posthog.com)Anonymous usage events — no screen content, no PII
License Validationscreenpi.pe APILicense key only. Cached 4h, 14-day offline grace.
Cloud SyncS3 (encrypted blobs)ChaCha20-Poly1305 ciphertext only. Server never sees plaintext.

Enterprise deployments can run fully air-gapped with local transcription (Parakeet/Whisper) and local AI (Ollama). In this configuration the only network request is license validation, which supports 14-day offline operation.

Data Flow Summary

On Device — Always Local, No Network

Screen Capture

ScreenCaptureKit (macOS) WGC (Win) · xcap (Linux)

Text Extraction

Accessibility Tree + OCR (hybrid, conditional)

Audio Processing

CPAL capture · Silero VAD Speaker diarization (ONNX)

Local Storage

SQLite DB (88 migrations) JPEG + Audio files FTS5 full-text index

Optional — Explicit Admin/User Opt-In

Cloud Transcription

Deepgram API (audio only, opt-in)

Cloud AI for scheduled tasks

Screenpipe Cloud (ZDR) Or BYOK: OpenAI, Anthropic

Cloud Sync

Zero-knowledge encrypted ChaCha20-Poly1305 blobs Server never sees plaintext

Never

Screen recordings sent to any server

Unencrypted data transmitted over network

Data shared with third parties

Screenpipe employees accessing user data

9. AI, Transcription & Confidential Compute

Screenpipe supports fully on-premise AI for both transcription and scheduled task execution. Enterprise users are free to use their own AI providers. Cloud AI through Screenpipe is optional and operates under zero data retention (ZDR) policies.

On-Premise Transcription

The following speech-to-text engines run entirely on-device with no network dependency. engine.rs

EngineModelNotes
Parakeet MLXparakeet-tdt-0.6b-v3-mlxMetal GPU acceleration on Apple Silicon. 25 languages. Fastest local option.
Parakeet CPUparakeet-tdt-0.6b-v3OpenBLAS. Cross-platform.
Whisper Large v3 Turboggml-large-v3-turbo.binDefault. 99 languages. Best accuracy/speed tradeoff.
Whisper Large v3ggml-large-v3.binHighest accuracy. Higher resource usage.
Whisper Tinyggml-tiny.binLightweight. For resource-constrained devices.
Qwen3 ASRqwen3-asr-0.6b-antirez0.6B multilingual model.
OpenAI-CompatibleCustom endpointConnect any OpenAI-compatible STT API (e.g., on-premise Whisper server).

AI for Scheduled Tasks

Scheduled task execution supports multiple AI providers. Enterprise users can bring their own API keys or use fully on-premise models. pipes/mod.rs

ProviderTypeData Retention
Ollama (local)On-premiseNo data leaves device. Runs at localhost:11434.
Custom OpenAI-CompatibleOn-premise / BYOKYour infrastructure, your policies. Configurable endpoint, API key, headers.
OpenAI (BYOK)Cloud — user's keySubject to OpenAI's API data usage policy (not used for training with API keys).
Anthropic (BYOK)Cloud — user's keySubject to Anthropic's API data usage policy (not used for training with API keys).
Screenpipe CloudCloud — managedNo prompt or completion content stored by Screenpipe. Requests route by model to Google Cloud Vertex AI, Anthropic, or OpenAI under their API data terms. Provider retention can vary; see the privacy policy for the current details.
Screenpipe Cloud (Confidential)Cloud — hardware enclaveCryptographic guarantee, not a policy. Prompts and outputs are encrypted end-to-end into a hardware enclave. Neither Screenpipe nor the enclave operator can read the data. Every request is verified against a remote attestation. Currently serving Gemma 4; more models rolling out. See subsection below.

Sources: providers/index.ts (provider routing) · gemini.ts (Vertex routing)

Confidential Cloud AI — Hardware Enclaves

Zero-data-retention is a policy (the provider promises not to log). Confidential compute is a cryptographic guarantee (the provider cannot read the data, even if compelled to). Select Screenpipe Cloud models run inside hardware enclaves so that Screenpipe, its infrastructure provider, and the underlying cloud vendor are all excluded from the trust boundary — only the user and the attested model binary can see the plaintext.

Confidential Inference — Request Path

Client (your device)

Fetches the enclave's remote-attestation document. Verifies it against open-source measurement code bundled in the Screenpipe SDK. If the attestation fails, the request is aborted before any data leaves the device.

▼ HPKE (RFC 9180) — encrypted to enclave public key

Screenpipe Gateway

Routes the opaque ciphertext. Cannot read prompt or output — HPKE payload is encrypted directly to the enclave's ephemeral public key, not to the gateway's.

Hardware Enclave

CPU TEE (Intel TDX or AMD SEV-SNP) + Nvidia Confidential GPU. Model binary + inference runtime measured at boot; the measurement is signed by the hardware root of trust. Memory is encrypted at the silicon level — host OS, hypervisor, and cloud operator cannot inspect it.

▼ Response re-encrypted inside the enclave

Client (decrypt)

Only the client holds the session key to decrypt the response. Prompt, context, and model output were never visible in plaintext to anyone in the middle.

Every session produces a fresh attestation. Replaying past attestation documents won't work — the client checks nonce + measurement + timestamp.

GuaranteeMechanism
ConfidentialityMemory encryption at the silicon level (Intel TDX / AMD SEV-SNP / Nvidia CC). Prompts and outputs are unreadable outside the enclave.
IntegrityRemote attestation signs a measurement of the exact model + runtime binary. Tampering changes the measurement, which clients reject.
TransportHPKE (RFC 9180) from the client directly to the enclave's ephemeral public key. Gateway, ISP, and cloud provider see only ciphertext.
VerifiabilityThe verifier is open source. Anyone can audit the code that decides whether an enclave is trustworthy — we don't ask you to trust Screenpipe's word.
No key escrowScreenpipe does not hold decryption keys. The enclave's key lives only in TEE-protected memory and is destroyed on tear-down.

Models & Roadmap

Confidential compute is live today for chat models. Additional workloads are rolling out:

WorkloadReview posture
Chat (Gemma 4)Live. Default for users who opt into the confidential model in Settings.
Additional chat models (Qwen, Llama, etc.)Rolling out.
Cloud transcription (Whisper / Parakeet)Planned. Currently on-device (local) or Deepgram (non-confidential, opt-in).
Confidential scheduled runtimePlanned. Scheduled task code will execute inside the enclave alongside the model, so even task-generated intermediate data never leaves TEE memory.

Infrastructure Partner

Confidential inference is operated in partnership with Tinfoil, a confidential-computing platform for AI workloads. Tinfoil provides the attested container runtime, hardware-root-of-trust attestation chain (Intel DCAP + AMD KDS + Nvidia CC), HPKE transport, and the open-source verifier. Their verifier is published under AGPL-3.0 and embedded in the Screenpipe SDK — every session's attestation can be independently checked against Tinfoil's supply-chain measurements. Screenpipe curates the models; Tinfoil handles the cryptographic machinery. Neither party holds decryption keys for user sessions.

Further reading: tinfoil.sh · Tinfoil Containers overview · open-source verifier · RFC 9180 (HPKE) · Intel TDX whitepaper · AMD SEV-SNP whitepaper

Enterprise recommendation: For maximum data control, deploy with on-premise Ollama or a custom OpenAI-compatible endpoint. No data leaves your network. If cloud AI is required (e.g., for frontier model quality), the confidential tier provides the strongest available guarantees short of self-hosting.

10. Testing & CI/CD Pipeline

Screenpipe maintains a multi-layered testing infrastructure across 14 CI/CD workflows, covering unit tests, integration tests, E2E tests, benchmarks, security audits, and longevity testing.

Testing & Release Pipeline

On Every PR / Push

cargo test

Unit + integration 12 crates, 3 platforms

cargo clippy + fmt

Linting + formatting All packages

cargo audit + deny

Supply chain scan Unused deps (machete)

E2E Tests (WebDriver IO + Mocha)

12 test scripts: app lifecycle, health check, search API, settings, timeline, WebSocket, MCP, onboarding. Platforms: macOS (arm64), Windows (x64), Linux. Video recording for debugging.

PII Removal Tests

27 pattern categories validated. Performance benchmarks for regex engine.

Scheduled

Longevity Test

4-hour stress run. Memory tracking CSV. Windows, every 4h.

Benchmarks (daily)

OCR: Apple / Tesseract / Win. STT: Whisper. DB: search accuracy, FTS perf.

Release

Desktop App: macOS (Intel + Apple Silicon) + Windows + Linux · CLI: cross-platform with LTO, codegen-units=1, strip · MCP Server: npm publish · Code Signing: SSL.com EV (Windows), Apple notarization (macOS)

Sources: ci.yml · style.yml (audit + lint) · e2e-test.yml · windows-integration-test.yml · benchmark.yml

Security-Specific Testing

Test CategoryDetails
cargo auditDependency vulnerability scanning on every PR. Blocks merge on known CVEs.
cargo denyLicense compliance + duplicate dependency detection. Prevents supply chain issues.
PII Redaction TestsONNX-based entity detection tests. Pattern matching validated across 27 categories.
Database IntegrityFTS contention tests, heavy read scenarios, FK constraint validation, audio reconciliation.
Longevity Testing4-hour continuous run on Windows (every 4h). Memory usage tracked via CSV. Detects leaks and resource exhaustion.
E2E SecuritySettings persistence, API health endpoints, MCP integration, WebSocket stability.

11. Compliance

StandardStatus
SOC 2 Type IISecurity evidence and trust materials can be reviewed during enterprise procurement. Scope, dates, and covered services should be verified against the current trust packet.
GDPRLocal-first deployments can support data minimization, retention control, deletion workflows, and data-residency reviews. Final GDPR posture depends on customer configuration, consent, data flow, and agreements.
HIPAAHealthcare deployments should be scoped around local-only or approved provider paths, retention policy, access controls, and BAA requirements where third-party processing is enabled.
Source Code AuditSource-available — full source code available for independent security review.

Liability & Data Responsibility

Local-first architecture shifts data liability to the deploying organization. Because all data is processed and stored on the user's device (or the organization's managed devices), Screenpipe does not act as a data processor for core functionality.

Enterprise controls enable compliance ownership: Admin policies, MDM deployment, content filters, data retention, and AI provider selection are all configurable by the organization. The enterprise admin controls what data is captured, how long it is retained, and where (if anywhere) it is transmitted.

Zero data retention for cloud features: When optional cloud features are enabled, the exact route matters. Cloud sync, BYOK providers, selected zero-data-retention providers, and confidential-compute routes have different retention and access properties that should be reviewed per deployment.

Source-available transparency: Security claims can be checked against the published source code. Organizations can review the codebase, fork it, or run modified builds to meet specific compliance requirements.

12. Source Code Audit

Screenpipe makes its source available under the Screenpipe Commercial License. The following modules are directly relevant to security review:

Capture Enginecrates/screenpipe-engine
Screen Capturecrates/screenpipe-screen
Audio Pipelinecrates/screenpipe-audio
Accessibilitycrates/screenpipe-a11y
Cryptographycrates/screenpipe-core/src/sync
Vault (At-Rest)crates/screenpipe-vault
PII Detectioncrates/screenpipe-core/src/pii_removal.rs
Scheduled Task Permissionscrates/screenpipe-core/src/pipes/permissions.rs
Databasecrates/screenpipe-db
AI Gatewaypackages/ai-gateway/src/providers
Team Encryptionapps/screenpipe-app-tauri/lib/team-crypto.ts
Enterprise Policyee
Full Repositorygithub.com/screenpipe/screenpipe

For documentation, see the Screenpipe Docs including the Scheduled tasks guide, Scheduled Task Permissions, Teams & Encryption, and Cloud Sync Architecture.

Security Contact

To report a vulnerability, request a security review for your organization, or discuss enterprise deployment: louis@screenpi.pe

Document version 1.3 · April 2026 · Screenpipe v2.4.x · Source-linked architecture notes for security review