Most URL shortener projects look simple from the outside, but feel surprisingly heavy once you try to deploy them.
Databases. Migrations. Environment variables. Admin dashboards. For many use cases, that’s a lot of complexity just to turn a long URL into a short one.
In this post, you’ll see a different approach: a single-file PHP URL shortener that you can drop into a folder like /u, visit https://yourhost.com/u, and start using almost immediately.
The usual problem with self-hosted short URLs
If you search “url shortener” on GitHub, you’ll find everything from tiny scripts to full-blown platforms with APIs, analytics dashboards, and user accounts.
Those are great when you need an entire product. But if you just want:
- Short URLs on your own domain
- A light script you understand
- Something you can easily move between servers
then a big framework-based app can feel like overkill.
Common pain points:
- Requires setting up a full database and importing schema
- Bundled with UI/UX and features you don’t need right now
- Hard to customize because there are too many moving parts
At the other extreme, super-minimal scripts often skip modern needs like QR codes or even the possibility of basic click stats, so you end up bolting on extra tools anyway.
A different approach: single-file PHP
The idea behind this project is simple:
“What if URL shortening was just one
index.phpfile you drop into a folder and it works?”
That’s exactly what the repository DodyBayuAp/url-shortener aims to provide:
a URL shortener in a single PHP file, licensed under MIT and designed to be easy to self-host.
Core goals:
-
Single file – all logic inside
index.php - No heavy setup – no installer, no extra CLI steps
- Self-hosted – runs on your own domain, under any public folder that supports PHP
- Customizable – you can open the file and actually understand what’s going on
Because it’s just PHP, it works on most shared hosting environments where PHP is already enabled, similar to many older but still popular PHP scripts.
How deployment works (step by step)
The deployment flow is intentionally short so that it fits typical dev and “semi-technical” workflows.
1. Download the file
Grab index.php from the GitHub repository and save it locally.
You don’t need Composer or a framework scaffold. If your server can run regular PHP files, you’re good.
2. Create a /u folder in your public root
Go to your public web root. Depending on your stack, that might be:
-
public_html/ -
www/ -
htdocs/ -
public/(e.g., in a Laravel app)
Create a new folder, for example:
./public/u
This folder will act as the “gateway” for all your short URLs.
3. Drop index.php inside that folder
Move the index.php file into your u folder:
public/
u/
index.php
At this point, any request to /u will be handled by that single PHP file.
4. Access https://yourhost.com/u
Open your browser and visit:
Replace yourhost.com with your actual domain (or http://localhost/u while testing). If PHP is correctly configured, your shortener UI or endpoint should load without additional setup.
No database migration. No .env wiring. No extra scaffolding. Just upload and go.
Where QR codes, mobile, and analytics fit in
Even though this project is intentionally small, you’re not locked out of modern features.
Here are three natural extensions:
1. QR codes
You can hook in a QR library or external API so each short link gets a corresponding QR code, which is especially useful for print materials and offline campaigns.
Typical flow:
- Create short URL
- Generate QR code for that short URL
- Display or download it from the same UI or an extra route
Because everything is inside one file, you only need to wire this feature in a single place instead of multiple controllers/services.
2. Mobile-friendly UI
No front-end framework is required. A simple HTML layout plus a bit of responsive CSS is enough to make the interface comfortable on mobile.
If you’re using this in your own stack, you can even wrap /u inside your existing styling to keep everything on-brand.
3. Basic click analytics
On each redirect, you can log things like:
- Timestamp
- Referer
- User agent
Even a basic log file or tiny database table will give you useful insights into which short links and campaigns are working.
Because this is self-hosted, you own the data, which is a big deal compared to many third-party URL shortener services.
Why a single-file URL shortener is still relevant
In a world of microservices, containers, and “platforms”, a single PHP file can feel almost nostalgic.
But it has real, practical advantages:
- Low friction – You can add it to almost any existing PHP-capable environment.
- Easy to migrate – Moving your shortener to another host is just copying one file.
- Auditable – You can read the entire logic in one place and know what happens to your URLs.
For indie devs, small teams, or solo creators, that trade-off makes sense: fewer dependencies, fewer surprises, less overhead.
Try it, tweak it, and star it ⭐
If you want to host short URLs on your own domain without wrestling with a heavy stack, this kind of single-file PHP shortener is a nice middle ground between “too simple” and “too complex”.
You get:
- Your own domain for short links
- Source code you can inspect and modify
- A deployment story that fits into a single README section
You can check out the project here:
👉 GitHub repo: https://github.com/DodyBayuAp/url-shortener
If you find it useful, don’t forget to leave a star on the repository — it’s a small gesture that really helps open-source projects stand out in a crowded GitHub search result page.
Top comments (0)