Flask API – Dakidarts® Hub

How to Shorten URLs Using Python: Build a URL Shortener Flask API

Dakidarts — Sun, 10 Nov 2024 16:36:50 +0000

In this tutorial, we’ll explore a quick and efficient way to create shortened URLs in Python, a handy solution for sharing long links on social media, emails, or text messages.

Plus, we’ll go the extra mile and package it as a simple Flask API, allowing users to shorten URLs on the fly!

Why Use a URL Shortener?

Long URLs can look messy and take up a lot of space, especially on platforms with character limits. A URL shortener can:

Improve link appearance and readability.
Track link clicks for analytics.
Simplify sharing on social platforms and in messages.

Common Use Cases:

Simplified URLs for mobile sharing or QR codes

Marketing and promotional links

Trackable social media links

Setting Up the Project Environment

We’ll use the pyshorteners library to handle URL shortening easily. First, install the required libraries:

pip install pyshorteners flask

Creating the URL Shortening Script in Python

The pyshorteners library offers a streamlined way to shorten URLs using various services (e.g., TinyURL, Bitly). Here’s how to shorten a URL:

import pyshorteners

def shorten_url(long_url):
    s = pyshorteners.Shortener()
    short_url = s.tinyurl.short(long_url)
    return short_url

# Example usage:
long_url = "https://example.com/some/very/long/url"
print("Shortened URL:", shorten_url(long_url))

Building a Flask API for URL Shortening

We’ll now create a Flask API that takes a URL as input and returns a shortened version.

Initialize the Flask App:

from flask import Flask, request, jsonify
import pyshorteners

app = Flask(__name__)

# URL shortening function
def shorten_url(long_url):
    s = pyshorteners.Shortener()
    return s.tinyurl.short(long_url)

# Flask route for URL shortening
@app.route('/shorten', methods=['POST'])
def api_shorten_url():
    data = request.json
    long_url = data.get("url")

    if not long_url:
        return jsonify({"error": "URL is required"}), 400

    try:
        short_url = shorten_url(long_url)
        return jsonify({"short_url": short_url}), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 500

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

Testing the Flask API

Once the Flask API is up and running, you can test it in a few different ways:

1. Using cURL:

To shorten a URL via cURL, open your terminal and execute the following command:

curl -X POST http://127.0.0.1:5000/shorten -H "Content-Type: application/json" -d '{"url": "https://example.com/some/very/long/url"}'

This command sends a POST request to the API endpoint with a JSON payload containing the URL you want to shorten. If the request is successful, you’ll see a JSON response similar to this:

{
    "short_url": "https://tinyurl.com/xyz123"
}

2. Using a Web Browser and API Testing Tools

If you prefer not to use the terminal, you can test the API using a browser extension like Postman or Insomnia. Here’s how:

Postman Setup:

Paste the JSON body:

Open Postman and create a new POST request.

Enter http://127.0.0.1:5000/shorten as the request URL.

In the “Body” tab, select “raw” and choose “JSON” from the dropdown menu.

{
    "url": "https://example.com/some/very/long/url"
}

Click Send to see the API’s response, which will contain the shortened URL.

3. Accessing the API from a Web Browser Script

You can even use JavaScript to test the API by running this code in the browser’s console:

fetch('http://127.0.0.1:5000/shorten', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({ url: 'https://example.com/some/very/long/url' })
})
.then(response => response.json())
.then(data => console.log('Shortened URL:', data.short_url))
.catch(error => console.error('Error:', error));

This script sends a POST request to the API and logs the shortened URL to the console.

The API will respond with a JSON object containing the shortened URL.

Expanding the Project

Analytics: Track the number of times each shortened URL is accessed.

Custom URL Shortening: Use services like Bitly or set up your own custom domain for shortened URLs.

Database Storage: Use a database to keep track of original URLs and their shortened versions.

Conclusion

Creating a URL shortener in Python is a fantastic way to learn about API development while building a useful tool.

This method can be expanded to create custom URL shorteners or analytics-backed services!

How to Generate QR Codes Using Python: Step-by-Step Guide & Flask API Bonus

Dakidarts — Fri, 08 Nov 2024 16:04:29 +0000

In today’s fast-paced digital world, QR codes have become an invaluable tool for sharing information quickly and effortlessly.

From linking to websites and connecting to Wi-Fi networks, to sending payment details and contact information, QR codes make information accessible in a single scan.

In this tutorial, we’ll guide you through creating your own QR codes using Python. With just a few lines of code, you’ll be able to generate scannable, customizable QR codes that are ready for any application.

Plus, we’ll show you how to create a QR code generator API, so you can add this functionality to your applications and services.

QR codes are an easy and popular way to share information in a scannable format. Let’s dive into how to generate one with Python, using the qrcode library.

Step 1: Install Required Libraries

First, install the qrcode and Pillow (PIL) libraries. qrcode generates QR codes, while Pillow handles image operations.

pip install qrcode[pil]

Step 2: Generate a Basic QR Code

Create a simple Python script to generate a QR code:

import qrcode

# Define data to encode
data = "https://example.com"

# Create QR code instance
qr = qrcode.QRCode(
    version=1,  # Controls size (1 is 21x21, higher is bigger)
    error_correction=qrcode.constants.ERROR_CORRECT_L,
    box_size=10,
    border=4,
)

# Add data to the instance
qr.add_data(data)
qr.make(fit=True)

# Create and save the image
img = qr.make_image(fill_color="black", back_color="white")
img.save("qrcode.png")

Explanation of Parameters:

version: Defines the complexity of the QR code (1–40).
error_correction: Adds error-correction capability, ensuring QR code readability even if damaged.
box_size: Specifies how many pixels each box of the QR code should be.
border: Controls the width of the border around the QR code.

This code generates a QR code that links to https://example.com and saves it as an image file called qrcode.png.

Bonus: Turning This Into a Flask API

To make this functionality accessible via an API, let’s use Flask. This API will allow users to submit text or URLs for QR code generation, with the result returned as an image file.

Step 1: Install Flask

Install Flask with:

pip install Flask

Step 2: Set Up the Flask API

Here’s how to create a basic Flask API that generates QR codes from user input:

from flask import Flask, request, send_file
import qrcode
import io

app = Flask(__name__)

@app.route('/generate_qr', methods=['POST'])
def generate_qr():
    data = request.json.get("data", None)
    if not data:
        return {"error": "No data provided"}, 400

    # Create QR code
    qr = qrcode.QRCode(
        version=1,
        error_correction=qrcode.constants.ERROR_CORRECT_L,
        box_size=10,
        border=4,
    )
    qr.add_data(data)
    qr.make(fit=True)
    img = qr.make_image(fill_color="black", back_color="white")

    # Save the QR code image in memory
    img_io = io.BytesIO()
    img.save(img_io, 'PNG')
    img_io.seek(0)

    return send_file(img_io, mimetype='image/png')

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

Explanation of the API

Route: /generate_qr – Accepts POST requests with JSON data.
Data Input: Expects a JSON body with a data key containing the text or URL to encode.
Image Output: Returns a generated QR code image as a PNG.

Testing the API

Run the Flask app:

python app.py

Test the API with a tool like Postman or curl:

curl -X POST -H "Content-Type: application/json" -d '{"data": "https://example.com"}' http://127.0.0.1:5000/generate_qr --output qrcode.png

The command above sends a POST request to your API and saves the output as qrcode.png.

Benefits of Using QR Codes

Instant Access to Information: QR codes bridge the gap between offline and online, instantly directing users to websites, forms, or contact information.

Enhanced User Experience: They make it easy for customers to access content with one scan, saving time and effort.

Wide Application Range: QR codes support a variety of data types, from URLs to encrypted information, making them versatile across different needs.

Customizable for Branding: QR codes can be personalized with colors, logos, and shapes, adding a branded touch to promotional material.

Use Cases for QR Codes

Marketing Campaigns: Direct users to specific promotions, product pages, or social media channels by embedding links in QR codes on printed materials.

Event Check-ins: Simplify registration and access control at events by providing digital tickets as QR codes that can be scanned on entry.

Payments: Use QR codes to facilitate secure, contactless payments, especially popular in retail and food service industries.

Contactless Menus: Restaurants can offer digital menus by placing QR codes on tables, letting patrons scan to view without needing a physical menu.

Networking: Business professionals can share contact details quickly by using QR codes on business cards, which link directly to contact information.

And that’s it! You now have a Python script and a Flask API to generate QR codes.