Skip to main content
Scriberr is an AI-powered media transcription and subtitle generation tool. It automatically transcribes video and audio content using advanced speech recognition models, making your content more accessible and searchable. In this tutorial, you’ll deploy a fully working Scriberr instance on Upsun. By the end, you’ll have your own private transcription service that you control.

​
Prerequisites

Before you begin, make sure you have: Resource note: Scriberr requires substantial resources. You’ll need a container with at least 10GB RAM and 40GB disk space. Keep this in mind when reviewing your Upsun plan.

​
Why self-host your transcription service?

Commercial transcription services charge per minute of audio. If you’re transcribing large amounts of content, those costs add up fast. Self-hosting gives you predictable monthly costs regardless of how much you transcribe. Privacy is another consideration. When you use external services, your audio files leave your infrastructure. With a self-hosted solution, your recordings never leave your control. This matters for sensitive content like internal meetings, legal recordings, or medical dictation. You also gain full control over your data. Keep transcriptions as long as you want, organize them however you prefer, and integrate with your own systems without API limitations.

​
Understanding the resource requirements

Scriberr runs AI models locally for transcription. These models need significant memory to load and run. The minimum requirement is 10GB RAM, and you’ll want 40GB of disk space for the models, temporary files during processing, and your transcription library. This configuration uses CPU inference rather than GPU. GPU would be faster, but CPU costs less and works well for Scriberr’s workflow. You upload files, then check back later for results. The processing time is longer, but you’re not waiting in real-time. The HIGH_MEMORY container profile in Upsun allocates the necessary resources for AI workloads. Expect higher hosting costs compared to a typical web application due to these requirements.

​
Current limitations

Scriberr is a single-user application with basic access control. You set up an admin username and password on first use. All subsequent access requires those credentials. There’s no support for multiple user accounts. If multi-user support matters to you, consider contributing to the Scriberr project.

​
Project setup

Start by cloning the example repository: 
git clone https://github.com/ralt/scriberr-upsun.git
cd scriberr-upsun
The repository structure is minimal. The only configuration you need is in .upsun/config.yaml. Scriberr itself gets downloaded during the build process.

​
Understanding the Upsun configuration

Here’s the complete configuration file: 
applications:
  scriberr:
    container_profile: HIGH_MEMORY
    type: python:3.11
    hooks:
      build: |
        set -ex
        curl -L https://github.com/rishikanthc/Scriberr/releases/download/v1.2.0/Scriberr_Linux_x86_64.tar.gz | tar xz
    variables:
      env:
        APP_ENV: production
        SECURE_COOKIES: false
        XDG_DATA_HOME: /app/data
        XDG_CONFIG_HOME: /app/data
    dependencies:
      python3:
        uv: "*"
    mounts:
      data:
        source: storage
        source_path: data
      nltk_data:
        source: storage
        source_path: nltk_data
    web:
      upstream:
        socket_family: tcp
        protocol: http
      commands:
        pre_start: ln -s /app/data/uv /tmp/uv
        start: ./scriberr
      locations:
        /:
          passthru: true

routes:
  https://{default}/:
    type: upstream
    upstream: scriberr:http
Let’s break down the key sections.

​
Container profile

container_profile: HIGH_MEMORY
The HIGH_MEMORY profile provides the memory allocation needed for AI inference. Standard profiles don’t provide enough RAM for the speech recognition models.

​
Build hook

hooks:
  build: |
    set -ex
    curl -L https://github.com/rishikanthc/Scriberr/releases/download/v1.2.0/Scriberr_Linux_x86_64.tar.gz | tar xz
During build, this downloads the Scriberr v1.2.0 binary from GitHub releases and extracts it. The binary includes everything needed to run the application.

​
Environment variables

variables:
  env:
    APP_ENV: production
    SECURE_COOKIES: false
    XDG_DATA_HOME: /app/data
    XDG_CONFIG_HOME: /app/data
These configure Scriberr’s runtime behavior. The XDG_* variables direct application data to a persistent mount so your configuration and transcriptions survive deployments.

​
Mounts

mounts:
  data:
    source: storage
    source_path: data
  nltk_data:
    source: storage
    source_path: nltk_data
Two persistent mounts store your data between deployments:
  • data: Stores your transcriptions, configuration, and downloaded AI models
  • nltk_data: Stores Natural Language Toolkit data used for text processing

​
Web configuration

web:
  upstream:
    socket_family: tcp
    protocol: http
  commands:
    pre_start: ln -s /app/data/uv /tmp/uv
    start: ./scriberr
Scriberr runs as an HTTP server. The pre_start command creates a symlink that works around a temporary directory issue with uv, the Python package manager. The start command runs the Scriberr binary.

​
Deploying to Upsun

With the configuration in place, create your Upsun project: 
upsun project:create
Follow the prompts to name your project and select a region. Then push your code to deploy: 
git push upsun main
The first deployment takes several minutes. Upsun downloads the Scriberr binary and builds your container. Subsequent deployments are faster since the build cache persists. Watch the deployment logs to track progress. When you see the deployment succeed message, your application is ready.

​
Accessing Scriberr

Get your application URL: 
upsun url --primary
The first time you access Scriberr, expect a slow response. Scriberr downloads the speech recognition models on first use. This happens once and the models persist in your data mount. Depending on the model size, this initial download takes a few minutes. After the download completes, you’ll see the Scriberr interface. You can then upload audio or video files for transcription.

​
Conclusion

You now have a private transcription service running on your own infrastructure. Upload audio or video files, and Scriberr generates accurate transcriptions using AI speech recognition. Your transcriptions stay on your infrastructure. You control the data retention and access. And your costs are predictable regardless of transcription volume. For more details on Scriberr’s features and configuration options, see the Scriberr documentation.
Ready to deploy your own AI-powered services? Start your free Upsun trial and get your applications running in minutes.
Last modified on April 14, 2026