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.
| Component | Algorithm | Parameters |
|---|---|---|
| Data Encryption | ChaCha20-Poly1305 | 256-bit key, 96-bit nonce, AEAD auth tag |
| Key Derivation | Argon2id v0x13 | 64 MB memory, 3 iterations, parallelism 4, 256-bit output, 256-bit salt |
| Searchable Encryption | HMAC-SHA256 | 256-bit output, normalized keywords (lowercase, trimmed, deduped) |
| Data Integrity | SHA-256 | Post-decryption verification checksum |
| At-Rest Vault | ChaCha20-Poly1305 + Argon2id | Password-derived keys, lock/unlock via screenpipe-vault crate |
| Team Config Encryption | AES-256-GCM | 96-bit random nonce per operation (Web Crypto API) |
| Team Key Wrapping | PBKDF2 + AES-256-GCM | 600,000 iterations, SHA-256, 128-bit salt |
| Credential Storage | Tauri Secure Store | OS 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
| Control | Details |
|---|---|
| Window Filtering | Exclude specific apps from capture (e.g., 1Password, banking). Admin-pushable include/exclude lists. Incognito window auto-detection (Safari, Chrome, Firefox). |
| URL Filtering | Exclude specific websites and URL patterns from capture. |
| Audio Device Selection | Enable/disable per device. Select specific microphones and system audio sources. |
| Monitor Selection | Choose which displays to record. Exclude specific monitors. Dynamic monitor connect/disconnect handling. |
| Data Retention | Auto-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 Detection | Pauses 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
| Category | Patterns |
|---|---|
| Financial | Credit card numbers (4-digit groups), IBAN (ISO 13616) |
| Government IDs | US Social Security Numbers (XXX-XX-XXXX) |
| Contact Info | Email (RFC 5322), formatted phone numbers (with country code), IPv4 addresses |
| Credentials | JWTs, PEM private keys, database connection strings (7 DB types), Bearer tokens, password fields, env var secrets |
| Service API Keys | AWS (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 |
| Secrets | BIP39 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 Type | Description |
|---|---|
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 & Day | Restrict execution to hours (HH:MM-HH:MM, midnight wrap) and weekdays. |
Offline Mode | Blocks all non-localhost outbound network requests from scheduled tasks. |
HTTPS-Only Install | Scheduled 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:
| Component | Details |
|---|---|
| Segmentation Model | Pyannote v3.0 (segmentation-3.0.onnx) — speaker activity detection on 10-second windows, runs via ONNX Runtime on-device |
| Speaker Embeddings | WeSpeaker CAM++ (wespeaker_en_voxceleb_CAM++.onnx) — 192-dimensional voice fingerprint per segment via filterbank features |
| Matching Algorithm | Cosine similarity with configurable threshold (default: 0.9). Embeddings stored locally in SQLite. At capacity: force-merge to closest speaker. |
| Calendar Integration | Calendar-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
| Feature | Details |
|---|---|
| Admin Policy | Lock 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 Deployment | Deploy via Kandji, Intune, or any MDM. Reads enterprise.json from managed directory. Auto-updates disabled for IT control. |
| License Management | Seat-based licensing with feature matrix. Cached 4 hours, 14-day offline grace period. |
| Write-Only Archive | Devices 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 Policy | Ed25519-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 Verification | The 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 Encryption | AES-256-GCM. Key generated on admin device, never sent to server. Shared via passphrase-protected invite (PBKDF2, 600K iterations). |
| Controlled UI | Hide chat, timeline, settings per device. Control AI models, transcription engines, scheduled task execution, data types. |
| Content Filter Push | Push window/URL filters to all devices. Team filters are additive and cannot be removed by members. |
| API Authentication | Non-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.
| Property | Value and what it means |
|---|---|
| Validity window | 3600s (1 hour). A fetched policy is honored for one hour after the control plane issued it. |
| Refresh cadence | 300s (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 margin | 3600 / 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 window | Fails 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 policy | Per-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 contains | Cause and owner |
|---|---|
| no policy loaded yet | The gateway has not completed a first successful policy fetch. |
| cached policy is past its validity window | Genuine refresh failure — the gateway could not reach us for over an hour. |
| clock disagreed with the signed issued_at | Your clock, not our availability. The message carries the measured delta. Fix NTP on the gateway host. |
| policy is not yet valid | Your 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:
| Feature | Destination | Data Transmitted |
|---|---|---|
| Cloud Transcription | Deepgram API | Audio 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 Connections | Google, Notion, etc. | Tokens stored locally, data fetched to device only |
| Analytics | PostHog (eu.i.posthog.com) | Anonymous usage events — no screen content, no PII |
| License Validation | screenpi.pe API | License key only. Cached 4h, 14-day offline grace. |
| Cloud Sync | S3 (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
| Engine | Model | Notes |
|---|---|---|
| Parakeet MLX | parakeet-tdt-0.6b-v3-mlx | Metal GPU acceleration on Apple Silicon. 25 languages. Fastest local option. |
| Parakeet CPU | parakeet-tdt-0.6b-v3 | OpenBLAS. Cross-platform. |
| Whisper Large v3 Turbo | ggml-large-v3-turbo.bin | Default. 99 languages. Best accuracy/speed tradeoff. |
| Whisper Large v3 | ggml-large-v3.bin | Highest accuracy. Higher resource usage. |
| Whisper Tiny | ggml-tiny.bin | Lightweight. For resource-constrained devices. |
| Qwen3 ASR | qwen3-asr-0.6b-antirez | 0.6B multilingual model. |
| OpenAI-Compatible | Custom endpoint | Connect 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
| Provider | Type | Data Retention |
|---|---|---|
| Ollama (local) | On-premise | No data leaves device. Runs at localhost:11434. |
| Custom OpenAI-Compatible | On-premise / BYOK | Your infrastructure, your policies. Configurable endpoint, API key, headers. |
| OpenAI (BYOK) | Cloud — user's key | Subject to OpenAI's API data usage policy (not used for training with API keys). |
| Anthropic (BYOK) | Cloud — user's key | Subject to Anthropic's API data usage policy (not used for training with API keys). |
| Screenpipe Cloud | Cloud — managed | No 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 enclave | Cryptographic 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.
| Guarantee | Mechanism |
|---|---|
| Confidentiality | Memory encryption at the silicon level (Intel TDX / AMD SEV-SNP / Nvidia CC). Prompts and outputs are unreadable outside the enclave. |
| Integrity | Remote attestation signs a measurement of the exact model + runtime binary. Tampering changes the measurement, which clients reject. |
| Transport | HPKE (RFC 9180) from the client directly to the enclave's ephemeral public key. Gateway, ISP, and cloud provider see only ciphertext. |
| Verifiability | The 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 escrow | Screenpipe 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:
| Workload | Review 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 runtime | Planned. 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 Category | Details |
|---|---|
| cargo audit | Dependency vulnerability scanning on every PR. Blocks merge on known CVEs. |
| cargo deny | License compliance + duplicate dependency detection. Prevents supply chain issues. |
| PII Redaction Tests | ONNX-based entity detection tests. Pattern matching validated across 27 categories. |
| Database Integrity | FTS contention tests, heavy read scenarios, FK constraint validation, audio reconciliation. |
| Longevity Testing | 4-hour continuous run on Windows (every 4h). Memory usage tracked via CSV. Detects leaks and resource exhaustion. |
| E2E Security | Settings persistence, API health endpoints, MCP integration, WebSocket stability. |
11. Compliance
| Standard | Status |
|---|---|
| SOC 2 Type II | Security evidence and trust materials can be reviewed during enterprise procurement. Scope, dates, and covered services should be verified against the current trust packet. |
| GDPR | Local-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. |
| HIPAA | Healthcare 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 Audit | Source-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:
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