Live streams

Record to your own server

Keep a project’s recording files on the customer’s own servers: MinIO step by step, or a shared Windows folder.

On Enterprise, a project can keep its recording files on the customer’s own servers instead of Kymoscope: an S3-compatible store (MinIO, NetApp StorageGRID, Dell ECS, a NAS’s S3 service, or AWS S3, Cloudflare R2, Wasabi, Google Cloud Storage) or a folder (a local disk, a Windows share, a NAS). The files stay end-to-end encrypted, are listed in Cloud like any other, and don’t count in your plan’s storage or days. This page sets up MinIO and a shared folder, step by step.

How it works

  • Own storage is set per project, by a project admin, in Project Settings → Storage. Apply to all my organization’s projects sets the same storage on every project you manage.
  • The senders write the files. The write key (or the folder) lives only in each sender’s config: the storage setting of Recording.
  • Members’ browsers read the files. The read key is sealed in your browser with the project key when you save it, so Kymoscope can’t read it, and never holds a write key.
  • Files are read from where the storage is reachable, usually the customer’s network.
  • Files go to <prefix>/<stream>/<recording>/ in a bucket and <folder>\<stream>\<recording>\ in a folder.
  • Changing a project’s storage applies to new files; files already stored stay readable where they are.

MinIO step by step

  1. Run MinIO on a server of the customer’s network, with a TLS certificate the browsers trust (the app is served over HTTPS, so it can’t read plain http://). MINIO_API_CORS_ALLOW_ORIGIN lets the app read from it (step 4).
    MinIO with Docker
    # public.crt and private.key in /srv/minio-certs: a certificate the customer's browsers trust
    docker run -d --name minio --restart unless-stopped -p 9000:9000 \
      -v /srv/minio:/data -v /srv/minio-certs:/certs \
      -e MINIO_ROOT_USER=customer-admin -e MINIO_ROOT_PASSWORD='<a long random secret>' \
      -e MINIO_API_CORS_ALLOW_ORIGIN=https://app.kymoscope.com \
      pgsty/minio:RELEASE.2026-08-04T00-00-00Z server /data --certs-dir /certs
  2. Create the bucket with the MinIO client, mc:
    Shell
    mc alias set customer https://minio.customer.local:9000 customer-admin '<a long random secret>'
    mc mb customer/recordings
  3. Create two keys: a read-only one for the app and a write one for the senders, each limited to the prefix (kymoscope here).
    read-policy.json
    {
      "Version": "2012-10-17",
      "Statement": [
        { "Effect": "Allow", "Action": ["s3:GetObject"], "Resource": ["arn:aws:s3:::recordings/kymoscope/*"] }
      ]
    }
    write-policy.json
    {
      "Version": "2012-10-17",
      "Statement": [
        { "Effect": "Allow", "Action": ["s3:PutObject"], "Resource": ["arn:aws:s3:::recordings/kymoscope/*"] }
      ]
    }
    Shell
    # the read key, for the app (members' browsers open files with it)
    mc admin policy create customer kymoscope-read read-policy.json
    mc admin user add customer kymoscope-read '<a long random secret>'
    mc admin policy attach customer kymoscope-read --user kymoscope-read
    
    # the write key, for the senders
    mc admin policy create customer kymoscope-write write-policy.json
    mc admin user add customer kymoscope-write '<another long random secret>'
    mc admin policy attach customer kymoscope-write --user kymoscope-write
  4. Allow the app’s origin (CORS). The bucket must allow GET from https://app.kymoscope.com (or the address you open the app at). The browser camera page and the browser SDK also write from the page, so they need PUT from it too; MinIO allows every method for the allowed origin.
    Shell
    # already set by MINIO_API_CORS_ALLOW_ORIGIN above; on a running MinIO:
    mc admin config set customer api cors_allow_origin=https://app.kymoscope.com
    mc admin service restart customer
  5. Enter the read key in the project. In the app, open the project, Settings → Storage, choose An S3 bucket and fill in Name (for example MinIO customer), Endpoint (https://minio.customer.local:9000), Bucket (recordings), Region (us-east-1), Prefix (kymoscope), and the Read access key and Read secret. Save storage checks the bucket from your browser first and says what is wrong (CORS, certificate, key, bucket name).
  6. Give each sender the write key, in its own format:
    collector.yaml
    streams:
      - name: Customer A DCS
        mode: record
        storage:
          s3:
            endpoint: https://minio.customer.local:9000
            region: us-east-1
            bucket: recordings
            prefix: kymoscope
            access_key_id: kymoscope-write
            secret_access_key: env:S3_WRITE_SECRET   # env: or file: keeps it out of this file
        sources: ...
    Python
    import os
    
    storage = {"s3": {"endpoint": "https://minio.customer.local:9000", "region": "us-east-1", "bucket": "recordings",
                      "prefix": "kymoscope", "access_key_id": "kymoscope-write",
                      "secret_access_key": os.environ["S3_WRITE_SECRET"]}}
    with LiveStream(API_KEY, "Rig A", mode="record", hz=1000, channels=8, state_path="kymoscope-state.json",
                    storage=storage) as stream:
        ...
    KymoscopeLiveTelemetry.ini (AC and LMU plugins)
    StorageEndpoint=https://minio.customer.local:9000
    StorageRegion=us-east-1
    StorageBucket=recordings
    StoragePrefix=kymoscope
    StorageAccessKey=kymoscope-write
    StorageSecretKey=<the write secret>
  7. Start the sender. Its start line names the storage, for example Recording files: every 1h → MinIO customer (buffer 2 GB). In Cloud the files show the storage’s name and open as usual from the customer’s network.

A shared folder step by step

  1. Share a folder, for example \\server\recordings. The account each sender runs as needs to write in it (Change on the share, Modify on the folder): for the collector its service account, for a plugin the Windows user who plays. Members who open recordings need read access.
    PowerShell on the file server
    # on the file server: the share and its folder, writable by the collector's service account
    New-Item -ItemType Directory D:\Recordings
    New-SmbShare -Name recordings -Path D:\Recordings -ChangeAccess "CUSTOMER\svc-kymoscope" -ReadAccess "CUSTOMER\Kymoscope users"
    icacls D:\Recordings /grant "CUSTOMER\svc-kymoscope:(OI)(CI)M" /grant "CUSTOMER\Kymoscope users:(OI)(CI)RX"
  2. Choose it in the project. In the app, open the project, Settings → Storage, choose A folder, give it a name (for example Recordings share) and press Save storage.
  3. Give each sender the folder:
    collector.yaml
    streams:
      - name: Customer A DCS
        mode: record
        storage: {folder: '\\server\recordings'}   # single quotes keep the backslashes
        sources: ...
    Python
    storage = {"folder": r"\\server\recordings"}
    KymoscopeLiveTelemetry.ini (AC and LMU plugins)
    StorageFolder=\\server\recordings
  4. Open files from Chrome or Edge. The first time you open one of the folder’s files in Cloud, press Choose the folder and pick \\server\recordings (type it in the dialog’s address bar, or map it as a drive first). The browser remembers it. The /camera page asks for the folder the same way when it starts recording. Other browsers can’t open folders.

Deleting old files

Your own storage keeps files until you delete them. The sender’s retention days setting (retention_days, RetentionDays, retentionDays) sets how long Kymoscope lists each new file in Cloud; to free the space as well, delete them on the storage on the same schedule:

MinIO
# delete files older than 365 days on the bucket itself
mc ilm rule add --expire-days 365 --prefix kymoscope/ customer/recordings

For a folder, a scheduled task that removes the stream folders’ files older than that does the same.

If something is wrong

What you seeWhat to do
The sender says “This project records to <name>: set storage in the sender’s config”Add the storage setting (above) and restart it. The files wait in its buffer meanwhile.
The sender says it can’t store recording chunks, and retriesIt can’t reach or write the storage: check the endpoint, the write key, the certificate, the folder’s permissions for the account it runs as.
Save storage says the browser can’t reach the bucketCORS (the app’s origin not allowed), a certificate the browser doesn’t trust, plain http://, or a host not reachable from this network.
A file in Cloud asks to choose a folderPick the project’s folder; use Chrome or Edge.
Recording refused: not in the planOwn storage needs Enterprise. A project set to its own storage never falls back to Kymoscope’s.