TuroYT/snowshare
TuroYT/snowshare has 112 GitHub stars and 8 forks. GitHot measured 0 stars in 24 hours and +1 in 7 days. Last checked 2026-11-18 22:29 UTC. Last push 2026-11-14.
Measured star growth
- in 24h
- 0
- in 7 days
- +1
- in 15 days
- Collecting history
- in 1 month
- Collecting history
Net star changes over overlapping periods, not daily totals. Missing measurements are left blank. Stars measure attention, not software quality.
About
A modern, secure file and link sharing platform built with Next.js, Prisma, and NextAuth. Share URLs, code snippets, and files with customizable expiration, privacy, and QR codes.
Web & AppsREADME.md
Original
SnowShare
SnowShare is a self-hosted app for sharing files, links and pastes. You run it on your own server, and anyone you send a link to can open it, with or without an account depending on how you set it up.
What it does
- Files: uploads are resumable (tus), so a dropped connection doesn't restart a 20 GB transfer. Several files can go in one share, and common formats are previewed in the browser.
- Links: a URL shortener with optional custom slugs.
- Pastes: text or code with syntax highlighting.
Any share can have an expiration date, a maximum number of views, a password and a QR code.
On the admin side you get user accounts (email/password or OAuth), optional email verification and CAPTCHA, separate quotas for anonymous and logged-in users, custom branding, and a choice between local disk and S3-compatible storage. There is also a REST API with API keys. The interface is translated into English, French, Spanish, German, Dutch and Polish.
Install with Docker
The image is on Docker Hub as turodev/snowshare, built for amd64 and arm64. Database migrations run when the container starts, so there is nothing to do by hand.
Docker Compose
Create a folder with this docker-compose.yml in it:
services:
db:
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: snowshare
volumes:
- db-data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 5s
timeout: 5s
retries: 10
app:
image: turodev/snowshare:latest
restart: unless-stopped
depends_on:
db:
condition: service_healthy
environment:
DATABASE_URL: postgres://postgres:${POSTGRES_PASSWORD}@db:5432/snowshare
NEXTAUTH_URL: ${NEXTAUTH_URL}
NEXTAUTH_SECRET: ${NEXTAUTH_SECRET}
ALLOW_SIGNUP: "true"
ports:
- "3000:3000"
volumes:
- uploads:/app/uploads
volumes:
db-data:
uploads:
Then generate a .env file next to it and start everything:
cat > .env <<EOF
NEXTAUTH_URL=http://localhost:3000
NEXTAUTH_SECRET=$(openssl rand -base64 32)
POSTGRES_PASSWORD=$(openssl rand -hex 24)
EOF
docker compose up -d
Replace NEXTAUTH_URL with your real URL if the instance is not only used locally. Open http://localhost:3000 and create the first account: it becomes the admin.
Plain docker run
If you'd rather not use Compose:
docker network create snowshare-net
docker run -d \
--name snowshare-db \
--network snowshare-net \
--restart unless-stopped \
-e POSTGRES_USER=postgres \
-e POSTGRES_PASSWORD=change-me \
-e POSTGRES_DB=snowshare \
-v snowshare-db:/var/lib/postgresql/data \
postgres:16-alpine
docker run -d \
--name snowshare \
--network snowshare-net \
--restart unless-stopped \
-p 3000:3000 \
-e DATABASE_URL="postgres://postgres:change-me@snowshare-db:5432/snowshare" \
-e NEXTAUTH_URL="http://localhost:3000" \
-e NEXTAUTH_SECRET="$(openssl rand -base64 32)" \
-e ALLOW_SIGNUP="true" \
-v snowshare-uploads:/app/uploads \
turodev/snowshare:latest
Write the generated NEXTAUTH_SECRET down. It signs sessions and download tokens, so if you recreate the container with a different one, everybody gets logged out.
Tags
latest follows the newest release. You can also pin a minor (1.5) or an exact version (1.5.4).
Updating
docker compose pull
docker compose up -d
With docker run, pull the new image, remove the snowshare container and start it again with the same command. Your data lives in the volumes, not in the container.
It's worth dumping the database before a big version jump:
docker compose exec db pg_dump -U postgres snowshare > snowshare-backup.sql
Other install methods are covered in docs/UPGRADE.md.
Configuration
Four variables are required:
| Variable | Description |
|---|---|
DATABASE_URL |
PostgreSQL connection string |
NEXTAUTH_URL |
Public URL of the instance |
NEXTAUTH_SECRET |
Random secret (openssl rand -base64 32) |
ALLOW_SIGNUP |
true or false, whether new users can register |
The rest is optional:
| Variable | Default | Description |
|---|---|---|
AUTH_TRUST_HOST |
Set to true behind a reverse proxy |
|
TRUSTED_PROXY_COUNT |
1 |
Number of reverse proxies in front of SnowShare |
PORT |
3000 |
Port the server listens on |
METRICS_TOKEN |
Enables Prometheus metrics at /api/metrics with a Bearer token |
|
UPLOAD_DIR |
./uploads |
Absolute path for local file storage, ignored when S3_BUCKET is set |
S3_BUCKET |
Setting it switches file storage to S3 | |
S3_REGION |
us-east-1 |
|
S3_ACCESS_KEY_ID |
||
S3_SECRET_ACCESS_KEY |
||
S3_ENDPOINT |
For S3-compatible services (MinIO, Garage, R2...) | |
NEXT_PUBLIC_DEFAULT_LOCALE |
en |
Fallback language: en, fr, es, de, nl or pl |
TELEMETRY |
true |
false turns analytics off |
PLAUSIBLE_DOMAIN |
Use your own Plausible site | |
PLAUSIBLE_HOST |
URL of your own Plausible instance |
Quotas, anonymous sharing, OAuth providers, SMTP, CAPTCHA, branding and S3 can also be changed from the admin panel, no restart needed.
Reverse proxy
Set NEXTAUTH_URL to the public HTTPS URL and add AUTH_TRUST_HOST=true.
SnowShare needs the real client IP for quotas, rate limiting and access logs. It reads it from X-Forwarded-For, and TRUSTED_PROXY_COUNT tells it how many proxies to skip from the right. The default of 1 fits a single nginx, Traefik or Caddy. Use 2 for something like Cloudflare in front of nginx, and 0 if the app is exposed directly (forwarding headers are then ignored).
File uploads go through /api/tus. If big uploads fail, check that the proxy isn't limiting the request body size (client_max_body_size 0; on nginx).
Where the data is
Uploaded files are in /app/uploads unless you use S3, and the database is in the Postgres volume. Those are the two things to back up. Expired shares are deleted every hour.
API
The REST API lives under /api/v1 and uses API keys, which you create from your profile page. Each instance serves its own docs at /api-docs, and the OpenAPI spec at /api/v1/openapi.json. Right after creating a key, the profile page also offers ShareX custom uploader files (.sxcu) for files and for the URL shortener.
Development
You need Node.js 24 or newer and a PostgreSQL database.
git clone https://github.com/TuroYT/snowshare
cd snowshare
npm install
cp .env.example .env
npx prisma migrate dev
npm run dev
Edit .env before running the migration. The dev server listens on http://localhost:3000.
To build the image from source instead of pulling it, run docker compose up -d --build from the repository.
Commands you'll use most:
npm run lint
npm run type-check
npm test
npx prisma studio
make help lists a few more shortcuts.
The stack is Next.js 16 (App Router), React 19, TypeScript, Prisma with PostgreSQL, NextAuth.js and TailwindCSS 4. server.js is a small custom server that wraps Next.js to handle tus uploads. Pages and API routes are in src/app, shared logic (auth, storage, quotas, share access) in src/lib, and translations in src/i18n/locales.
Contributing
Pull requests are welcome. Have a look at CONTRIBUTING.md and the Code of Conduct first. For security issues, see SECURITY.md.
Telemetry
SnowShare sends anonymous usage statistics to Plausible: no cookies, no personal data. Set TELEMETRY=false to turn it off, or use PLAUSIBLE_DOMAIN and PLAUSIBLE_HOST to send the data to your own Plausible instance.