🧭 Routing and View Functions

What Is Routing?

Routing is the process of deciding which piece of your code answers a given URL and HTTP method. In Flask you declare routes with the @app.route decorator, which pairs a URL pattern with a Python function called a view function. When a request arrives, Flask's URL dispatcher finds the matching route and runs its view.

Think of routing as a receptionist directing visitors: the URL is the name a visitor asks for, and the router walks them to the right office (view function). If nobody by that name exists, they're politely turned away with a 404.

Basic Routes & HTTP Methods

The simplest route maps a fixed path to a function. Whatever the function returns becomes the response body.

from flask import Flask

app = Flask(__name__)


@app.route("/")
def home():
    return "Hello, World!"


@app.route("/about")
def about():
    return "About page"

By default a route answers only GET requests. To accept others, list them in methods. This is how one URL can both show a form (GET) and process it (POST):

from flask import request, render_template


@app.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        username = request.form["username"]
        return f"Logging in {username}..."
    # GET: show the form
    return render_template("login.html")

Dynamic Routes & Converters

Real apps need URLs like /user/ray or /post/42. Flask captures the changing part with angle brackets and passes it to your view as an argument.

@app.route("/user/<username>")
def show_user(username):
    return f"User: {username}"


@app.route("/post/<int:post_id>")
def show_post(post_id):
    return f"Post number {post_id}"

The <int:post_id> syntax uses a converter: it only matches integers and hands your function a real int, not a string. Flask ships several converters:

You can combine several variables in one pattern:

@app.route("/blog/<int:year>/<int:month>/<int:day>")
def blog_by_date(year, month, day):
    return f"Posts from {year}-{month:02d}-{day:02d}"

When the built-ins aren't enough, write a custom converter. Here's one that splits a plus-separated list, so /tags/python+flask+web arrives as a Python list:

from werkzeug.routing import BaseConverter


class ListConverter(BaseConverter):
    def to_python(self, value):
        return value.split("+")

    def to_url(self, values):
        return "+".join(str(v) for v in values)


app.url_map.converters["list"] = ListConverter


@app.route("/tags/<list:tags>")
def show_tags(tags):
    return f"Tags: {', '.join(tags)}"

Building URLs with url_for

Never hardcode URLs. Instead, ask Flask to build them from the view function's name with url_for(). If you later change a route's path, every generated URL updates automatically — no broken links.

from flask import url_for, redirect


@app.route("/user/<username>")
def profile(username):
    return f"Profile: {username}"


@app.route("/me")
def me():
    # Build the URL for profile(username="ray")
    return redirect(url_for("profile", username="ray"))

url_for handles more than the path. Extra keyword arguments become query-string parameters, and special ones control the output:

url_for("search", q="flask tutorial", page=2)
# -> "/search?q=flask+tutorial&page=2"

url_for("home", _external=True)
# -> "http://example.com/"

url_for("profile", username="ray", _anchor="bio")
# -> "/user/ray#bio"

View Functions & Responses

A view function reads the request and returns a response. The request object holds everything about the incoming call:

View functions can return many kinds of response. Flask is flexible about what "a response" is:

from flask import jsonify, render_template, make_response, redirect, url_for, abort


@app.route("/text")
def text():
    return "Plain text"  # a string becomes an HTML response


@app.route("/page")
def page():
    return render_template("page.html", title="Hi")  # rendered template


@app.route("/api/data")
def data():
    return jsonify(name="Flask", awesome=True)  # JSON response


@app.route("/old")
def old():
    return redirect(url_for("page"))  # 302 redirect


@app.route("/missing")
def missing():
    abort(404)  # raise an HTTP error


@app.route("/custom")
def custom():
    resp = make_response("Created!", 201)         # body + status code
    resp.headers["X-Custom"] = "value"
    return resp

You can attach a status code simply by returning a tuple — return body, status. Here's a compact JSON API using that idiom:

from flask import Flask, request, jsonify

app = Flask(__name__)
USERS = {"1": {"id": "1", "name": "John"}}


@app.route("/api/users/<user_id>")
def get_user(user_id):
    user = USERS.get(user_id)
    if user is None:
        return jsonify(error="User not found"), 404
    return jsonify(user)


@app.route("/api/users", methods=["POST"])
def create_user():
    if not request.is_json:
        return jsonify(error="JSON required"), 415
    data = request.get_json()
    if "name" not in data:
        return jsonify(error="'name' is required"), 400
    new_id = str(len(USERS) + 1)
    USERS[new_id] = {"id": new_id, "name": data["name"]}
    return jsonify(USERS[new_id]), 201

Organizing with Blueprints

As routes multiply, a single file gets unwieldy. Blueprints let you group related routes — authentication, the main site, an admin area — into separate modules that you register onto the app.

# app/auth/routes.py
from flask import Blueprint, render_template, redirect, url_for

auth_bp = Blueprint("auth", __name__, url_prefix="/auth")


@auth_bp.route("/login", methods=["GET", "POST"])
def login():
    return render_template("auth/login.html")


@auth_bp.route("/logout")
def logout():
    return redirect(url_for("main.home"))

# app/__init__.py
def create_app():
    app = Flask(__name__)
    from app.auth.routes import auth_bp
    from app.main.routes import main_bp
    app.register_blueprint(auth_bp)
    app.register_blueprint(main_bp)
    return app

The url_prefix="/auth" means every route in that blueprint is served under /auth/.... When building URLs to a blueprint route, prefix the endpoint with the blueprint name:

url_for("auth.login")   # -> "/auth/login"
url_for("main.home")    # -> "/"

Error Handling

When something goes wrong you want a friendly, consistent response — an HTML page for a website, JSON for an API. Register error handlers for the status codes you care about:

@app.errorhandler(404)
def not_found(error):
    return render_template("errors/404.html"), 404


@app.errorhandler(500)
def server_error(error):
    return render_template("errors/500.html"), 500

Use abort() to trigger an error from inside a view, and combine it with checks for a clean guard-clause style:

from flask import abort


@app.route("/user/<username>")
def show_user(username):
    user = lookup_user(username)
    if user is None:
        abort(404)              # not found
    if not current_user_can_view(user):
        abort(403)              # forbidden
    return render_template("user.html", user=user)

Hands-on Exercise

import secrets
from flask import Flask, request, redirect, abort, render_template_string

app = Flask(__name__)
LINKS = {}

FORM = """
<form method="post" action="/shorten">
  <input name="url" placeholder="https://..." size="40">
  <button>Shorten</button>
</form>
"""


@app.route("/")
def index():
    return render_template_string(FORM)


@app.route("/shorten", methods=["POST"])
def shorten():
    url = request.form["url"]
    code = secrets.token_urlsafe(4)
    LINKS[code] = {"url": url, "visits": 0}
    return f"Short link: /{code}"


@app.route("/<code>")
def follow(code):
    link = LINKS.get(code)
    if link is None:
        abort(404)
    link["visits"] += 1
    return redirect(link["url"])


@app.route("/<code>/stats")
def stats(code):
    link = LINKS.get(code)
    if link is None:
        abort(404)
    return f"{code} -> {link['url']} ({link['visits']} visits)"


@app.errorhandler(404)
def not_found(e):
    return "That short link doesn't exist.", 404


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

Summary & Quiz

📚 Further Reading

• Flask — Routing
• Flask — Modular Applications with Blueprints
• Flask — Handling Application Errors
• Werkzeug — URL Routing & Converters

🚀 What's Next?

Your routes currently return bare strings and hand-built HTML. Next we bring in the Jinja2 templating engine so you can render clean, reusable HTML pages with layouts, loops, and dynamic data.