Flask: A Lightweight Python Web Framework
/flask
Flask is a Python web framework that wraps two libraries directly: Werkzeug for request and response handling, and Jinja for templates. It's lightweight, built on WSGI, and ships suggestions instead of requirements, so you pick your own database layer, auth, and folder structure. Reach for it if you want to assemble a web app from parts you choose; skip it if you'd rather a framework hand you a finished structure already.
Understanding the Flask Microframework
Flask is a Python web framework built directly on WSGI, the standard interface between Python code and a web server. It started as a thin layer connecting Werkzeug's request handling to Jinja's templating, and the project has kept that scope narrow since: Flask suggests how to build things without requiring a specific database, authentication system, or file layout.
Key Characteristics of Flask
- โBuilt on WSGI, the interface Python web servers use to talk to your application code.
- โWraps Werkzeug for request and response handling and Jinja for templates, instead of writing either layer from scratch.
- โNo required project layout or fixed dependency set; the framework suggests patterns rather than enforcing them.
- โRoutes are registered with a plain @app.route() decorator on a function, as shown in Flask's own quick-start example.
- โStarts a local dev server with the `flask run` command, listening at http://127.0.0.1:5000/ by default.
- โExtendable through community-built packages rather than a built-in plugin system of its own.
- โMaintained by the Pallets organization, which also maintains Werkzeug and Jinja.
- โReleased under the BSD-3-Clause license.
Running a Basic Flask App
Flask's README doesn't include a pip install command in the facts documented here, so the exact install step is not clearly documented in this material. What it does show is how to run the app once written: save a script as app.py, then run `flask run` from that directory. The built-in dev server starts at http://127.0.0.1:5000/, and you stop it with Ctrl+C.
Creating Your First Flask Route
Flask's own quick-start example is short: import Flask, create `app = Flask(__name__)`, then decorate a function with `@app.route("/")` that returns a string like "Hello, World!". Save that as app.py and start it with `flask run`; the dev server prints its own address at startup.
Strengths
- โSmall surface area: the quick-start example gets you to a running route in four lines.
- โWerkzeug and Jinja are separate, documented libraries you can read up on directly, not framework-internal magic.
- โNo forced ORM, auth system, or folder structure, so a small service isn't fighting the framework's opinions.
- โMaintained by the Pallets organization, which also owns the two libraries Flask depends on.
- โBSD-3-Clause license, with no restrictive terms attached.
Considerations Before Choosing Flask
- โณNo enforced project layout means larger apps are on you to structure; Flask's README frames that as a deliberate choice, not something it hides.
- โณThe facts available here don't cover deployment, configuration, or testing patterns, so you'll be reading Werkzeug, Jinja, and extension docs separately rather than one unified manual.
- โณExtensions come from the community rather than the core project, and this material doesn't document any vetting process for them.
- โณInstall steps themselves aren't part of the documented material here, only how to run an app once it's written.
Other Python Web Frameworks to Consider
Frequently Asked Questions About Flask
Flask is released under the BSD-3-Clause license, according to its GitHub repository.
WSGI is the standard interface between Python code and a web server. Flask is described as a lightweight framework built on that interface, rather than one that defines its own way of talking to a server.
Werkzeug and Jinja are two separate libraries, both maintained by the Pallets organization, that Flask wraps directly: Werkzeug covers WSGI-level request and response handling, and Jinja covers templating.
Flask's own README says it's meant to be easy to start with while still able to grow into more complex applications, though the material here doesn't document specifics of what that growth looks like.
Flask doesn't require a specific project layout or dependency set. It suggests patterns and leaves the actual choices, like which database library or auth system to use, to the developer.
Flask points contributors to a written contributing guide covering how to report issues, request features, ask or answer questions, and open pull requests.
The problem it solves
Writing straight to WSGI means handling routing, requests, and responses by hand with no template layer included. Full-featured frameworks solve that, but usually decide your ORM, auth, and directory layout as part of the package. Flask sits in between: it wraps Werkzeug for the WSGI-level work and Jinja for templates, then stops there, leaving dependency and layout choices to whoever builds on top of it.
Best use cases
- โขBuilding a small API or service where you want to pick your own ORM, auth, and folder layout instead of inheriting one.
- โขPrototyping quickly. A working route takes four lines of code.
- โขLearning how WSGI, routing, and templating fit together without a larger framework's abstractions in the way.
- โขAdding a thin HTTP layer in front of an existing Python script or library.
Who should try it โ and who should skip
Try Flask if you want to build a Python web app or API where you choose the ORM, auth, and folder structure yourself, and you don't mind reading Werkzeug and Jinja's own docs when you need more than the core provides. Skip it if you want a framework that ships those decisions made for you already; that's a different trade-off than the one Flask is built around.
Related repositories
Still deciding about flask?
One click hands the question to an AI along with this page โ see what it says about flask.