Privacy Controls

from videodb.capture import CaptureClient

client = CaptureClient(client_token=token)

# Request explicit permissions (OS dialogs appear)
await client.request_permission("microphone")
await client.request_permission("screen_capture")

# User must grant permission before capture can start
channels = await client.list_channels()

import { CaptureClient } from 'videodb/capture';

const client = new CaptureClient({ sessionToken: token });

// Request explicit permissions (OS dialogs appear)
await client.requestPermission('microphone');
await client.requestPermission('screen-capture');

// User must grant permission before capture can start
const channels = await client.listChannels();

# Backend (holds API key)
conn = videodb.connect()  # Uses VIDEODB_API_KEY

# Generate short-lived token for client
token = conn.generate_client_token(expires_in=600)  # 10 minutes

# Send token to desktop app (never send API key)

// Backend (holds API key)
const conn = connect();  // Uses VIDEO_DB_API_KEY

// Generate short-lived token for client
const token = await conn.generateClientToken(600);  // 10 minutes

// Send token to desktop app (never send API key)

# Each permission triggers an OS dialog
await client.request_permission("microphone")
await client.request_permission("screen_capture")
# For system audio on macOS
await client.request_permission("system_audio")

// Each permission triggers an OS dialog
await client.requestPermission('microphone');
await client.requestPermission('screen-capture');
// For system audio on macOS
await client.requestPermission('system-audio');

await client.start_session(
    capture_session_id=cap_id,
    channels=[
        {"name": "mic:default", "store": False},       # Process only
        {"name": "display:1", "store": False},         # Process only
        {"name": "system_audio:default", "store": False}
    ]
)

await client.startCaptureSession({
    sessionId: capId,
    channels: [
        { channelId: "mic:default", store: false },       // Process only
        { channelId: "display:1", store: false },         // Process only
        { channelId: "system_audio:default", store: false }
    ]
});

await client.start_session(
    capture_session_id=cap_id,
    channels=[
        {"name": "mic:default", "store": True},        # Keep for search
        {"name": "display:1", "store": False},         # Don't store screen
        {"name": "system_audio:default", "store": True}
    ]
)

await client.startCaptureSession({
    sessionId: capId,
    channels: [
        { channelId: "mic:default", store: true },        // Keep for search
        { channelId: "display:1", store: false },         // Don't store screen
        { channelId: "system_audio:default", store: true }
    ]
});

# Delete capture session and all associated data
cap = conn.get_capture_session("cap-xxx")
cap.delete()

# Delete specific video
video = coll.get_video("m-xxx")
video.delete()

// Delete capture session and all associated data
const cap = await conn.getCaptureSession("cap-xxx");
await cap.delete();

// Delete specific video
const video = await coll.getVideo("m-xxx");
await video.delete();

def get_user_data(end_user_id):
    """Get all data for a user (GDPR access request)"""
    sessions = conn.list_capture_sessions(end_user_id=end_user_id)
    return {"sessions": [s.to_dict() for s in sessions]}

def delete_user_data(end_user_id):
    """Delete all user data (GDPR deletion request)"""
    sessions = conn.list_capture_sessions(end_user_id=end_user_id)
    for session in sessions:
        session.delete()

async function getUserData(endUserId) {
    // Get all data for a user (GDPR access request)
    const sessions = await conn.listCaptureSessions({ endUserId });
    return { sessions };
}

async function deleteUserData(endUserId) {
    // Delete all user data (GDPR deletion request)
    const sessions = await conn.listCaptureSessions({ endUserId });
    for (const session of sessions) {
        await session.delete();
    }
}