cloudparts

AWS Chalice

A Flask-style Python framework for AWS Lambda: decorators turn functions into API routes and event handlers, and one chalice deploy creates the functions, API and IAM policy.

What it is
API frameworks (http api frameworks)
Used for
Serverless functions (FaaS),Infrastructure as code
Type
Managed service on AWS
Made by
Amazon Web Services
License
Apache 2.0
Facts checked
23 October 2026
Website Source code

What it is

A Chalice app is a Python file with an app = Chalice(app_name=...) object and decorated functions. @app.route("/orders/{id}") adds a REST endpoint behind Amazon API Gateway; @app.schedule, @app.on_s3_event, @app.on_sqs_message and similar decorators connect a function to a timer, a bucket, a queue or a topic, and there are WebSocket handlers, authorizers (IAM, Cognito or your own function), blueprints for splitting an app across files, and middleware. All routes share one Lambda function, api_handler; each event handler gets its own. chalice local serves the routes on your machine for quick testing.

Deployment is part of the framework. chalice deploy packages your code and the dependencies in requirements.txt, calls the AWS APIs through the Python SDK to create or update the Lambda functions, API and event sources, and records what it made per stage in .chalice/deployed/<stage>.json. By default it reads your code to generate the IAM policy the functions need; you can turn that off and supply your own. For CloudFormation-based pipelines, chalice package writes a SAM template and a deployment.zip instead, --pkg-format terraform writes a Terraform file, and the chalice.cdk construct embeds an app in an AWS CDK stack. A given app must stick to one route: switching between chalice deploy and a packaged deployment creates a second set of resources.

Chalice is an AWS open-source project under Apache 2.0. Releases have slowed to roughly one a year (1.32.0 in May 2025, 1.33.0 in May 2026, adding Python 3.14), but the repository is still active: in October 2026 it gained Python 3.15 and arm64 support that had not yet been released.

Why teams pick it

  • Very little to learn for Python developers: Flask-like routes plus decorators for AWS events, and the README promises a deployed API in under 30 seconds
  • One command deploys everything, including an IAM policy generated from the AWS calls in your code
  • Can hand off to SAM, Terraform or the CDK when the app needs to join a larger infrastructure-as-code setup
  • Maintained by AWS and still on 1.x since 2017, under a promise of backward compatibility within each major version

Watch out for

  • AWS Lambda and Python only; there is no way to target another cloud or runtime
  • Its own docs say the feature set is purposely small and it restricts how an app is structured and deployed
  • Releases are now infrequent, one in the year to May 2026, and mostly track Python versions rather than add features
  • Resources created by chalice deploy live outside CloudFormation, so moving to chalice package later means a fresh set of resources

Alternatives

What all http api frameworks have in common →Compare side by side →
DropshotOpen sourceA Rust crate for REST APIs whose OpenAPI document is generated from the handler functions’ types, written for the Oxide control plane and used across its services.StarletteOpen sourceA small ASGI toolkit for Python: routing, requests and responses, middleware, WebSockets and a test client, usable as a whole framework or piece by piece, and the base FastAPI is built on.+1 FastAPI

How it fits with other technologies

app.py: a route, a schedule and a queue consumer · python

from chalice import Chalice, Rate

app = Chalice(app_name="orders")

@app.route("/orders/{order_id}")          # API Gateway -> api_handler
def get_order(order_id):
    return {"id": order_id, "status": "shipped"}

@app.schedule(Rate(5, unit=Rate.MINUTES))  # its own Lambda + schedule
def sweep(event):
    ...

@app.on_sqs_message(queue="receipts")     # triggered by SQS
def on_receipt(event):
    for record in event:
        print(record.body)

# $ chalice local                 -> http://localhost:8000
# $ chalice deploy --stage prod

See it in a real stack

No architecture uses AWS Chalice yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2016–2026

On July 11, 2016 the AWS Developer Tools team released a preview of the Python Serverless Microframework for AWS, soon known by its package name, Chalice. Its programming model copied Flask, which the team picked for its reputation for simplicity, and its goal was to minimize the time to a working API: one chalice deploy packaged the code, created the Lambda function and API Gateway resources and returned a URL. It lived in the awslabs organization and was explicitly not yet meant for production.

Chalice 1.0.0 became generally available on July 31, 2017, with a promise of backward compatibility within each major version. By then it handled dependencies with C extensions, pure Lambda functions, scheduled events, generated IAM policies, authorizers and CI pipelines. Later releases added WebSockets and Terraform packaging (1.10, 2019), built-in support for the AWS CDK (1.22, 2021) and CDK v2 (1.27, 2022).

After that the pace slowed to maintenance: new Python versions as Lambda adds them, old ones dropped, and dependency updates. The project, now under the aws organization on GitHub, is still maintained in 2026 but adds few new features.

Why it’s built this way

A Flask-style decorator API
Flask was already familiar to many Python developers, so routes and handlers needed little explanation and the framework stayed small.
Deploy with the SDK, not CloudFormation
Calling the AWS APIs directly kept the tool self-contained: no template to write or stack to manage. CloudFormation, Terraform and CDK output were added later for teams that need them.
Generate the IAM policy from the code
Writing least-privilege policies by hand is a common stumbling block; analysing the AWS calls the app makes produced a starting policy automatically.
One Lambda function for all routes
Every API request goes to a single api_handler function, and Chalice dispatches it to the right view inside, so the whole API deploys as one unit; event handlers get functions of their own.

Timeline

  1. 2016

    Developer preview released on July 11

  2. 2017

    Chalice 1.0.0 generally available on July 31

  3. 2019

    Terraform packaging and experimental WebSockets in 1.10

  4. 2021

    Built-in AWS CDK construct in 1.22

  5. 2022

    CDK v2 support in 1.27

  6. 2026

    1.33.0 in May adds Python 3.14, drops 3.9

Sources12 · facts checked 23 October 2026

Improve this page on GitHub