DEV Community

Cover image for How to Create a Simple URL Shortener Tool with Python
ZeroByteCode
ZeroByteCode

Posted on

3 1

How to Create a Simple URL Shortener Tool with Python

A URL shortener tool allows users to take a long URL and convert it into a shorter, more manageable link. We can build a simple version of this tool using Python and Flask, a lightweight web framework.

Prerequisites

Before starting, ensure you have the following:

  • Python installed on your system (Python 3.6+ is recommended).
  • Flask installed. You can install Flask using pip.

Step 1: Setting Up Your Environment

First, you need to create a virtual environment and install Flask. Open your terminal and run the following commands:

# Create a virtual environment
python -m venv myenv

# Activate the virtual environment
# On Windows
myenv\Scripts\activate
# On macOS/Linux
source myenv/bin/activate

# Install Flask
pip install Flask
Enter fullscreen mode Exit fullscreen mode

Step 2: Writing the Code

Create a directory for your project, e.g., url_shortener, and inside it, create a Python file called app.py. We'll break down the code into sections.

Importing Required Libraries

from flask import Flask, request, redirect, url_for
import string
import random
Enter fullscreen mode Exit fullscreen mode

Setting Up Flask App and Database

We'll use a simple in-memory dictionary to store the URL mappings. For a more robust solution, you might use a database like SQLite or PostgreSQL.

app = Flask(__name__)
url_mapping = {}
Enter fullscreen mode Exit fullscreen mode

Function to Generate Short URLs

We'll create a function that generates a short URL key.

def generate_short_url():
    characters = string.ascii_letters + string.digits
    short_url = ''.join(random.choice(characters) for _ in range(6))
    return short_url
Enter fullscreen mode Exit fullscreen mode

Route to Handle URL Shortening

This route will take a long URL from the user and return a shortened version.

@app.route('/shorten', methods=['POST'])
def shorten_url():
    original_url = request.form['url']
    short_url = generate_short_url()
    url_mapping[short_url] = original_url
    return f'Shortened URL: {request.host_url}{short_url}'
Enter fullscreen mode Exit fullscreen mode

Route to Redirect Short URLs

This route will redirect users from the short URL to the original long URL.

@app.route('/<short_url>')
def redirect_url(short_url):
    original_url = url_mapping.get(short_url)
    if original_url:
        return redirect(original_url)
    else:
        return 'URL not found', 404
Enter fullscreen mode Exit fullscreen mode

Main Function to Run the App

if __name__ == "__main__":
    app.run(debug=True)
Enter fullscreen mode Exit fullscreen mode

Step 3: Running the Tool

Save your app.py file and run it from the terminal:

python app.py
Enter fullscreen mode Exit fullscreen mode

The Flask development server will start, and you can access the URL shortener tool by navigating to http://127.0.0.1:5000 in your web browser.

Step 4: Testing the Tool

To shorten a URL, you can use a tool like curl or a simple HTML form. Here's a basic HTML form for testing:

<!DOCTYPE html>
<html>
<head>
    <title>URL Shortener</title>
</head>
<body>
    <form action="http://127.0.0.1:5000/shorten" method="post">
        <label for="url">Enter URL to shorten:</label>
        <input type="text" id="url" name="url">
        <input type="submit" value="Shorten">
    </form>
</body>
</html>
Enter fullscreen mode Exit fullscreen mode

Save this HTML code as index.html and open it in your web browser. Enter a URL to shorten and submit the form. You should see a shortened URL that you can use to test the redirection functionality.

Conclusion

By following these steps, you can create a simple URL shortener tool using Python and Flask.

This tool can be further enhanced with additional features such as user authentication, analytics, and a database for storing URL mappings persistently.

Alternatively you can also read how to create a simple URL Shortener tool using Python.

Want to learn more? Explore programming articles, tips and tricks on ZeroByteCode.

Sentry image

See why 4M developers consider Sentry, “not bad.”

Fixing code doesn’t have to be the worst part of your day. Learn how Sentry can help.

Learn more

Top comments (2)

Collapse
 
stokry profile image
Stokry • Edited

I will do something like this:

import hashlib

url_dict = {}

BASE_URL = "http://localhost/"

def shorten_url(url):
    hash_object = hashlib.md5(url.encode())
    short_code = hash_object.hexdigest()[:6]
    short_url = BASE_URL + short_code
    url_dict[short_code] = url
    return short_url

def get_original_url(short_code):
    return url_dict.get(short_code, "Short URL not found!")

if __name__ == "__main__":
    while True:
        print("1. Shorten a URL")
        print("2. Retrieve original URL")
        print("3. Exit")
        choice = input("Enter your choice: ")

    if choice == '1':
        url = input("Enter the URL to shorten: ")
        short_url = shorten_url(url)
        print(f"Short URL is: {short_url}")
    elif choice == '2':
        short_url = input("Enter the short URL: ")
        short_code = short_url.replace(BASE_URL, "")
        original_url = get_original_url(short_code)
        print(f"Original URL is: {original_url}")
    elif choice == '3':
        break
    else:
        print("Invalid choice, please try again.")
Enter fullscreen mode Exit fullscreen mode
Collapse
 
zerobytecode profile image
ZeroByteCode

Nice, this is also cool and well-written.

A Workflow Copilot. Tailored to You.

Pieces.app image

Our desktop app, with its intelligent copilot, streamlines coding by generating snippets, extracting code from screenshots, and accelerating problem-solving.

Read the docs