URL shortener is one that reduces a long URL into something considerably shorter. It’s very useful in case you would like to pass a link through social networks or by SMS in such a manner that the link doesn’t look cluttered. We are, in this post, going to walk you through building a basic URL shortener using Python.

Prerequisites

Before we begin, ensure you have the following:

Basic knowledge of Python.
Familiarity with web frameworks like Flask.
A working installation of Python and pip.
Basic understanding of web development concepts.
A text editor like VSCode or Sublime.

Install Python and Flask

If you don’t have Python installed, download and install the latest version from the official website. Then, install Flask:

pip install Flask

Project Setup

Create Project Folder:
Create a new folder for your project.

   mkdir url_shortener
   cd url_shortener

Create Virtual Environment (optional but recommended):

   python -m venv venv
   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`

Create a Basic File Structure:
Structure the project as follows:

   url_shortener/
   ├── app.py
   ├── models.py
   ├── controllers/
   │   ├── redirects_controller.py
   │   └── api_controller.py
   ├── templates/
   │   └── index.html
   └── static/
       └── style.css

Database Design

We’ll use SQLite for simplicity, but this project can be extended to work with other databases like PostgreSQL or MySQL.

Create a Database: The database will have a table to store the original and shortened URLs.

   CREATE TABLE links (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     original_url TEXT NOT NULL,
     short_url TEXT NOT NULL UNIQUE
   );

Add Sample Data: You can populate it with some test data to check the application.

The Link Model

In models.py, we’ll define the structure for the URL and provide functions to interact with the database.

import sqlite3
import random
import string

DATABASE = 'url_shortener.db'

def get_db():
    db = sqlite3.connect(DATABASE)
    db.row_factory = sqlite3.Row
    return db

def generate_short_url():
    return ''.join(random.choices(string.ascii_letters + string.digits, k=6))

class Link:
    @staticmethod
    def create(original_url):
        short_url = generate_short_url()
        db = get_db()
        db.execute("INSERT INTO links (original_url, short_url) VALUES (?, ?)", 
                   (original_url, short_url))
        db.commit()
        return short_url

    @staticmethod
    def get_original_url(short_url):
        db = get_db()
        row = db.execute("SELECT original_url FROM links WHERE short_url = ?", (short_url,)).fetchone()
        if row:
            return row['original_url']
        return None

Setting Up Dependencies

Make sure to import the necessary dependencies in your main application file, app.py.

from flask import Flask, redirect, render_template, request, jsonify
from models import Link

Creating Controllers

Redirects Controller

In controllers/redirects_controller.py, create a controller that handles the redirection to the original URL.

from flask import redirect
from models import Link

def redirect_to_url(short_url):
    original_url = Link.get_original_url(short_url)
    if original_url:
        return redirect(original_url)
    return "URL not found", 404

API Controller

In controllers/api_controller.py, we’ll create an API endpoint to generate short URLs.

from flask import jsonify, request
from models import Link

def create_short_url():
    original_url = request.json.get('original_url')
    if original_url:
        short_url = Link.create(original_url)
        return jsonify({"short_url": short_url}), 201
    return jsonify({"error": "Invalid URL"}), 400

Setting Up Routes

In app.py, set up the routes for redirecting, creating, and displaying the basic interface.

from flask import Flask, render_template, request
from controllers.redirects_controller import redirect_to_url
from controllers.api_controller import create_short_url

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/<short_url>')
def redirect_to_short_url(short_url):
    return redirect_to_url(short_url)

@app.route('/api/create', methods=['POST'])
def api_create():
    return create_short_url()

if __name__ == '__main__':
    app.run(debug=True)

Application Controller

In app.py, ensure all the routes are registered and controllers are correctly wired. We already did this with the index, redirect_to_short_url, and api_create routes.

Basic Web Interface

In templates/index.html, create a basic form where users can input a URL and get a shortened version.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>URL Shortener</title>
    <link rel="stylesheet" href="/static/style.css">
</head>
<body>
    <div class="container">
        <h1>URL Shortener</h1>
        <form action="/" method="POST">
            <input type="url" name="url" placeholder="Enter URL" required>
            <button type="submit">Shorten</button>
        </form>
        {% if shortened_url %}
            <p>Shortened URL: <a href="{{ shortened_url }}" target="_blank">{{ shortened_url }}</a></p>
        {% endif %}
    </div>
</body>
</html>

In app.py, add a route to handle form submissions and generate a short URL.

@app.route('/', methods=['POST'])
def shorten_url():
    original_url = request.form['url']
    short_url = Link.create(original_url)
    shortened_url = request.host_url + short_url
    return render_template('index.html', shortened_url=shortened_url)

Adding Error Pages

It’s important to handle errors like invalid URLs or broken links gracefully. Flask allows you to easily add custom error pages.

In app.py, add error handling for 404 errors.

@app.errorhandler(404)
def page_not_found(error):
    return render_template('404.html'), 404

Create a 404.html page in the templates/ folder:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>404 - Not Found</title>
</head>
<body>
    <h1>Oops! The URL you are looking for is not found.</h1>
</body>
</html>

Conclusion

You’ve now developed a simple but functional URL shortener using Python and Flask. The project included defining routes, controllers, and a web interface. From this foundation, you can add more advanced features like user authentication, analytics, and custom short URL schemes.