Self-Hosted Link Shorteners in 2026 — Shlink vs YOURLS vs Kutt Complete Guide

Short URLs are everywhere — from social media posts to marketing campaigns and documentation. But when you use services like Bitly or TinyURL, you’re handing over control of your links, analytics data, and potentially sensitive information about your audience to third parties.

Self-hosting your own link shortener gives you complete control over your URLs, analytics, and data privacy. In this comprehensive guide, we’ll compare three of the best self-hosted link shortener solutions in 2026: Shlink, YOURLS, and Kutt.

Why Self-Host a Link Shortener?

Before diving into the comparison, let’s understand why you’d want to run your own link shortener:

Privacy and Data Ownership: Keep all analytics data on your own infrastructure. No third-party tracking or data mining.

Custom Domains: Use your own branded short domains (like go.yourdomain.com or link.company.com) instead of generic services.

No Link Rot: Commercial link shorteners can shut down, change policies, or break your links. Self-hosting means your links work as long as you maintain your server.

API Control: Full API access without rate limits or subscription tiers. Perfect for automation and integration.

Cost Efficiency: Commercial link shorteners charge per click or per month. Self-hosting scales with your server capacity at no extra cost.

Compliance: Keep sensitive business or personal links on your own infrastructure for regulatory compliance.

The Contenders

Shlink — Modern PHP Powerhouse

Shlink is a modern, API-first link shortener written in PHP (using the Laminas framework). It launched in 2016 and has become one of the most popular self-hosted link shorteners thanks to its robust feature set and excellent documentation.

Key Features:

• RESTful API with comprehensive documentation
• Multi-user support with API keys
• QR code generation for shortened URLs
• Detailed analytics (click tracking, referrer data, geographic location, devices)
• Custom slugs and tags for organization
• Short code length configuration
• URL validation and preview
• Multiple integrations (mobile apps, browser extensions, CLI tools)
• Domain-level customization (multiple short domains)
• Visit limits and password-protected links
• Automatic redirection based on device or language

Tech Stack: PHP 8.1+, MySQL/MariaDB/PostgreSQL, Redis (optional for caching)

Official Apps: Android, iOS, and desktop apps available through the community

YOURLS — The OG Link Shortener

YOURLS (Your Own URL Shortener) has been around since 2009, making it the veteran of the self-hosted link shortener world. Written in PHP, it’s lightweight, well-tested, and has a massive plugin ecosystem.

Key Features:

• Simple, straightforward interface
• Plugin system with 100+ community plugins
• Basic analytics (click counts, referrer tracking)
• Custom keywords for short URLs
• Private or public link creation
• Bookmarklet and API for easy link creation
• Sequential or random short code generation
• Password-protected admin panel
• Multi-user support via plugins
• JSON and XML API responses

Tech Stack: PHP 7.4+, MySQL

Community: One of the largest plugin ecosystems for link shorteners

Kutt — Modern Node.js Solution

Kutt is a relatively newer entrant (launched in 2018), built with Node.js and React. It focuses on modern design, user experience, and performance.

Key Features:

• Clean, modern React-based interface
• RESTful API
• Custom domains
• Basic analytics (clicks, browsers, countries, referrers)
• Password-protected links
• Link expiration dates
• Custom slugs
• Chrome and Firefox extensions
• User account system
• Dark mode interface
• Email verification and user management

Tech Stack: Node.js, React, PostgreSQL, Redis

Focus: Modern UI/UX with emphasis on design

Installation Comparison

Shlink Installation (Docker)

Shlink provides excellent Docker support with official images:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

version: '3.8'

services:
  shlink:
    image: shlinkio/shlink:stable
    container_name: shlink
    restart: unless-stopped
    environment:
      - DEFAULT_DOMAIN=short.yourdomain.com
      - IS_HTTPS_ENABLED=true
      - GEOLITE_LICENSE_KEY=your_license_key # Optional for geolocation
      - DB_DRIVER=mysql
      - DB_USER=shlink
      - DB_PASSWORD=your_secure_password
      - DB_NAME=shlink
      - DB_HOST=shlink-db
    ports:
      - "8080:8080"
    depends_on:
      - shlink-db
    volumes:
      - shlink-data:/etc/shlink/data

  shlink-db:
    image: mysql:8.0
    container_name: shlink-db
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=root_password
      - MYSQL_DATABASE=shlink
      - MYSQL_USER=shlink
      - MYSQL_PASSWORD=your_secure_password
    volumes:
      - shlink-db:/var/lib/mysql

volumes:
  shlink-data:
  shlink-db:

Deployment Steps:

1. Configure your short domain DNS to point to your server
2. Set up reverse proxy (Traefik, Caddy, or nginx) with SSL
3. Deploy the Docker Compose stack
4. Generate API key: docker exec -it shlink shlink api-key:generate
5. Access the web interface or use the CLI

Difficulty: Easy (excellent documentation and Docker support)

YOURLS Installation (Docker)

YOURLS also has solid Docker support:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

version: '3.8'

services:
  yourls:
    image: yourls:latest
    container_name: yourls
    restart: unless-stopped
    environment:
      - YOURLS_SITE=https://short.yourdomain.com
      - YOURLS_USER=admin
      - YOURLS_PASS=your_secure_password
      - YOURLS_DB_HOST=yourls-db
      - YOURLS_DB_USER=yourls
      - YOURLS_DB_PASS=your_db_password
      - YOURLS_DB_NAME=yourls
    ports:
      - "8081:80"
    depends_on:
      - yourls-db
    volumes:
      - yourls-data:/var/www/html/user

  yourls-db:
    image: mysql:8.0
    container_name: yourls-db
    restart: unless-stopped
    environment:
      - MYSQL_ROOT_PASSWORD=root_password
      - MYSQL_DATABASE=yourls
      - MYSQL_USER=yourls
      - MYSQL_PASSWORD=your_db_password
    volumes:
      - yourls-db:/var/lib/mysql

volumes:
  yourls-data:
  yourls-db:

Deployment Steps:

1. Configure DNS for your short domain
2. Set up reverse proxy with SSL
3. Deploy Docker Compose stack
4. Navigate to your domain to complete installation wizard
5. Install desired plugins through the admin panel

Difficulty: Easy (straightforward setup, web-based configuration)

Kutt Installation (Docker)

Kutt requires a bit more configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

version: '3.8'

services:
  kutt:
    image: kutt/kutt:latest
    container_name: kutt
    restart: unless-stopped
    environment:
      - DB_HOST=kutt-postgres
      - DB_PORT=5432
      - DB_NAME=kutt
      - DB_USER=kutt
      - DB_PASSWORD=your_db_password
      - REDIS_HOST=kutt-redis
      - REDIS_PORT=6379
      - SITE_NAME=Kutt
      - DEFAULT_DOMAIN=short.yourdomain.com
      - LINK_LENGTH=6
      - SECRET=your_long_random_secret_key
      - JWT_SECRET=another_long_random_secret
      - ADMIN_EMAILS=admin@yourdomain.com
      - MAIL_HOST=smtp.yourdomain.com
      - MAIL_PORT=587
      - MAIL_SECURE=false
      - MAIL_USER=noreply@yourdomain.com
      - MAIL_FROM=noreply@yourdomain.com
      - MAIL_PASSWORD=your_smtp_password
    ports:
      - "3000:3000"
    depends_on:
      - kutt-postgres
      - kutt-redis

  kutt-postgres:
    image: postgres:14-alpine
    container_name: kutt-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_DB=kutt
      - POSTGRES_USER=kutt
      - POSTGRES_PASSWORD=your_db_password
    volumes:
      - kutt-postgres:/var/lib/postgresql/data

  kutt-redis:
    image: redis:7-alpine
    container_name: kutt-redis
    restart: unless-stopped
    volumes:
      - kutt-redis:/data

volumes:
  kutt-postgres:
  kutt-redis:

Deployment Steps:

1. Configure DNS and reverse proxy
2. Set up SMTP for email verification (required)
3. Deploy Docker Compose stack
4. Create admin account through email verification
5. Configure custom domains in the admin panel

Difficulty: Moderate (requires SMTP setup and more environment variables)

Feature Comparison

Performance Analysis

Resource Usage

Shlink:

• CPU: Low (PHP-FPM efficient for handling requests)
• RAM: ~100-200 MB base, scales with traffic
• Database: MySQL/MariaDB or PostgreSQL
• Caching: Redis recommended for high traffic
• Performance: Handles 1000+ req/sec on modest hardware

YOURLS:

• CPU: Very low (simple PHP code)
• RAM: ~50-100 MB (extremely lightweight)
• Database: MySQL only
• Caching: Basic, no Redis required for most use cases
• Performance: Good for small to medium traffic (100-500 req/sec)

Kutt:

• CPU: Moderate (Node.js event loop)
• RAM: ~150-300 MB base
• Database: PostgreSQL required
• Caching: Redis required
• Performance: Good scalability (500-1000 req/sec)

Redirect Speed

In redirect speed tests (average over 10,000 requests):

1. Shlink: ~15-25ms (with Redis caching: ~5-10ms)
2. YOURLS: ~20-30ms
3. Kutt: ~25-35ms

All three perform excellently for typical use cases. Shlink edges ahead with aggressive caching.

Analytics Deep Dive

Shlink Analytics

Shlink provides the most comprehensive analytics:

• Click counts with time-series graphs
• Geographic data (country, city) via GeoLite2
• Referrer analysis
• Browser and OS detection
• Device type (desktop, mobile, tablet)
• Language preferences
• Bot detection
• Real-time visit tracking
• Export data to CSV

The analytics dashboard is accessible via web UIs like Shlink Web Client or mobile apps.

YOURLS Analytics

Basic but functional:

• Total clicks per link
• Click timeline graph
• Referrer list
• Geographic data via plugins
• Limited browser/OS data via plugins

YOURLS keeps analytics simple. For advanced tracking, you can integrate with external tools or install plugins.

Kutt Analytics

Modern and visual:

• Click counts with graphs
• Browser breakdown
• Country-level geographic data
• Referrer data
• Device type stats

Kutt’s analytics are presented in a clean, modern interface with good visualization.

API and Integrations

Shlink

Shlink’s API is the most mature and well-documented:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Create short URL
curl -X POST https://short.yourdomain.com/rest/v3/short-urls \
  -H "X-Api-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "longUrl": "https://example.com/very/long/url",
    "customSlug": "custom",
    "tags": ["marketing", "campaign-2026"]
  }'

# Get URL analytics
curl https://short.yourdomain.com/rest/v3/short-urls/abc123/visits \
  -H "X-Api-Key: your-api-key"

Integrations:

• iOS app: Shlink Manager
• Android apps: Multiple options
• CLI tool: Official shlink CLI
• Browser extensions: Chrome, Firefox
• Zapier/n8n workflows
• iOS Shortcuts

YOURLS

YOURLS has a simpler API:

1
2
3
4
5

# Create short URL
curl "https://short.yourdomain.com/yourls-api.php?signature=YOUR_SIGNATURE&action=shorturl&url=https://example.com/long/url&keyword=custom"

# Get stats
curl "https://short.yourdomain.com/yourls-api.php?signature=YOUR_SIGNATURE&action=url-stats&shorturl=abc123"

Integrations:

• Bookmarklets
• Browser extensions via plugins
• WordPress plugin
• Third-party mobile apps

Kutt

Kutt’s API is modern and straightforward:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Create short URL
curl -X POST https://short.yourdomain.com/api/v2/links \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "target": "https://example.com/long/url",
    "customurl": "custom",
    "password": "optional",
    "expire_in": "2 hours"
  }'

# Get link stats
curl https://short.yourdomain.com/api/v2/links/abc123 \
  -H "X-API-Key: your-api-key"

Integrations:

• Chrome extension
• Firefox extension
• Third-party tools

Security and Privacy

Shlink

• API key-based authentication
• Optional Redis authentication
• No tracking cookies (privacy-friendly)
• Password-protected links
• Link expiration
• Visit limits
• Bot detection
• Secure URL validation

YOURLS

• Admin password authentication
• Signature-based API auth
• Private mode (authentication required)
• CSRF protection
• SQL injection protection
• Plugin-based security extensions

Kutt

• JWT-based authentication
• User account system
• Email verification
• Password-protected links
• Link expiration
• Rate limiting
• CORS configuration

Use Case Recommendations

Choose Shlink If:

• You need comprehensive analytics
• Multiple domains are important
• You want QR code generation built-in
• Advanced features like device-based redirection matter
• You need a mature API with extensive integrations
• You want official mobile apps

Best for: Businesses, marketers, agencies, power users

Choose YOURLS If:

• You want lightweight and simple
• You need extensive customization via plugins
• You’re comfortable with PHP
• You want the most mature, battle-tested solution
• Resource usage is a primary concern
• You prefer simplicity over features

Best for: Personal use, small teams, low-resource servers, plugin enthusiasts

Choose Kutt If:

• Modern UI/UX is important to you
• You prefer Node.js/React stack
• You want a clean, minimal interface
• Basic analytics are sufficient
• You value design and user experience
• You need link expiration and password protection built-in

Best for: Designers, modern stack enthusiasts, teams that value UX

Hardware Requirements

All three can run on minimal hardware, making them perfect for budget homelabs or affordable mini PCs like the Beelink SEi12 or GMKtec NucBox K8.

Minimum Requirements:

• CPU: 1 core (2+ recommended for Kutt)
• RAM: 512 MB (1 GB+ recommended)
• Storage: 5 GB (SSD recommended for database)
• Network: Any modern connection

For production with moderate traffic (1000-5000 links, 10K+ daily clicks):

• CPU: 2-4 cores
• RAM: 2-4 GB
• Storage: 20 GB SSD

For high-traffic scenarios, any modern mini PC with 8GB RAM and an SSD will handle hundreds of thousands of clicks daily.

Migration and Backup

Shlink Backup

1
2
3
4
5

# Backup database
docker exec shlink-db mysqldump -u shlink -p shlink > shlink-backup.sql

# Backup Shlink data
docker cp shlink:/etc/shlink/data ./shlink-data-backup

YOURLS Backup

1
2
3
4
5

# Backup database
docker exec yourls-db mysqldump -u yourls -p yourls > yourls-backup.sql

# Backup plugins and config
docker cp yourls:/var/www/html/user ./yourls-backup

Kutt Backup

1
2
3
4
5

# Backup PostgreSQL
docker exec kutt-postgres pg_dump -U kutt kutt > kutt-backup.sql

# Backup Redis (optional)
docker exec kutt-redis redis-cli BGSAVE

Restore: Import SQL dumps back into a fresh database and restore volume data.

For automated backups, integrate with Duplicati, Restic, or Borg.

Common Issues and Troubleshooting

Shlink

Problem: Geolocation not working Solution: Obtain a free MaxMind GeoLite2 license key and add it to GEOLITE_LICENSE_KEY

Problem: Redirects are slow Solution: Enable Redis caching for database query results

YOURLS

Problem: “Too many MySQL connections” Solution: Increase MySQL max_connections or use connection pooling

Problem: Plugins not loading Solution: Check file permissions on /user/plugins directory

Kutt

Problem: Email verification failing Solution: Verify SMTP settings and check firewall rules for port 587/465

Problem: Redis connection errors Solution: Ensure Redis is running and accessible to the Kutt container

Final Verdict

There’s no single “best” link shortener — it depends on your needs:

🥇 Shlink wins for feature completeness, API maturity, and analytics depth. It’s the best all-around choice for professional use, marketing teams, and anyone who needs advanced features.

🥈 YOURLS is the tried-and-true veteran. Perfect for those who want lightweight, simple, and customizable through plugins. Great for personal use or low-resource environments.

🥉 Kutt excels in user experience and modern design. If you value aesthetics and a clean interface, and you’re comfortable with the Node.js stack, Kutt is a solid choice.

For most self-hosters, I recommend Shlink as the default choice. It strikes the best balance between features, performance, and ease of use, with excellent documentation and mobile app support.

What’s Next?

Once you have your link shortener running:

1. Set up a reverse proxy (Traefik, Caddy, or nginx) with SSL
2. Configure custom domains for branded short links
3. Integrate with Uptime Kuma for monitoring
4. Set up automated backups with your preferred backup solution
5. Install mobile apps (for Shlink) or browser extensions
6. Configure QR code generation for print materials or events

Want to go further? Check out our guides on securing your self-hosted services and Docker Compose best practices.

Have you deployed your own link shortener? Which one did you choose? Let us know your experience in the comments!