SlowAPI

https://slowapi.readthedocs.io/en/latest
Admin
SlowAPI is a rate limiting library for Starlette and FastAPI, adapted from flask-limiter, supporting...
Tokens:3,897
Snippets:18
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Development Environment Setup

Source: https://slowapi.readthedocs.io/en/latest/index

Provides instructions for setting up the development environment for SlowApi using Poetry. This includes installing dependencies and running tests.

```shell
$ poetry install

```

```shell
$ pytest

```

--------------------------------

### Install SlowApi

Source: https://slowapi.readthedocs.io/en/latest/index

Installs the SlowApi library using pip. This is the first step to using SlowApi for rate limiting in your Starlette or FastAPI applications.

```shell
$ pip install slowapi

```

--------------------------------

### Apply Global Limit to All Routes with SlowApi

Source: https://slowapi.readthedocs.io/en/latest/examples

This example demonstrates how to apply a default rate limit to all routes in a Starlette application using SlowApi. It initializes the Limiter with a global limit and adds the SlowAPIMiddleware to the application. It also shows how to handle RateLimitExceeded exceptions.

```Python
from starlette.applications import Starlette
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.middleware import SlowAPIMiddleware
from slowapi.errors import RateLimitExceeded

limiter = Limiter(key_func=get_remote_address, default_limits=["1/minute"])
app = Starlette()
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
app.add_middleware(SlowAPIMiddleware)

# this will be limited by the default_limits
async def homepage(request: Request):
    return PlainTextResponse("Only once per minute")

app.add_route("/home", homepage)

```

--------------------------------

### FastAPI Rate Limiting Setup

Source: https://slowapi.readthedocs.io/en/latest/index

Shows how to integrate SlowApi with a FastAPI application. It includes setting up the limiter, handling exceptions, and applying rate limits to different routes using decorators.

```python
from fastapi import FastAPI
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded

limiter = Limiter(key_func=get_remote_address)
app = FastAPI()
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

# Note: the route decorator must be above the limit decorator, not below it
@app.get("/home")
@limiter.limit("5/minute")
async def homepage(request: Request):
    return PlainTextResponse("test")

@app.get("/mars")
@limiter.limit("5/minute")
async def homepage(request: Request, response: Response):
    return {"key": "value"}


```

--------------------------------

### Disable SlowApi Limiter Entirely

Source: https://slowapi.readthedocs.io/en/latest/examples

This example demonstrates how to completely disable the SlowApi limiter, which can be useful for testing purposes. Disabling the limiter makes it as if it were not present in the application. This can be done by setting `enabled=False` during initialization or by changing the `limiter.enabled` attribute.

```Python
limiter = Limiter(key_func=get_remote_address, enabled=False)

@app.route("/someroute")
@limiter.exempt
def t(request: Request):
    return PlainTextResponse("I'm unlimited")

```

```Python
limiter.enabled = False

```

--------------------------------

### Use Redis as Backend for SlowApi Limiter

Source: https://slowapi.readthedocs.io/en/latest/examples

This example shows how to configure SlowApi to use Redis as the backend for storing rate limiting data. The `storage_uri` parameter is used to specify the Redis connection details, including the host, port, and database number.

```Python
limiter = Limiter(key_func=get_remote_address, storage_uri="redis://<host>:<port>/n")

```

--------------------------------

### Exempt a Route from Global Limit with SlowApi

Source: https://slowapi.readthedocs.io/en/latest/examples

This example shows how to exempt a specific route from the globally applied rate limits in a SlowApi-integrated Starlette application. The `@limiter.exempt` decorator is used on the route function to bypass the rate limiting.

```Python
@app.route("/someroute")
@limiter.exempt
def t(request: Request):
    return PlainTextResponse("I'm unlimited")

```

--------------------------------

### Starlette Rate Limiting Setup

Source: https://slowapi.readthedocs.io/en/latest/index

Demonstrates how to set up SlowApi with a Starlette application. It configures a limiter with a '5/minute' rate limit for a homepage route and handles rate limit exceeded exceptions.

```python
from starlette.applications import Starlette
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.util import get_remote_address
from slowapi.errors import RateLimitExceeded

limiter = Limiter(key_func=get_remote_address)
app = Starlette()
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

@limiter.limit("5/minute")
async def homepage(request: Request):
    return PlainTextResponse("test")

app.add_route("/home", homepage)

```

--------------------------------

### Get Remote Address from Request (SlowAPI)

Source: https://slowapi.readthedocs.io/en/latest/api

Returns the IP address associated with the remote client making the request, defaulting to '127.0.0.1' if no address is determined.

```python
from slowapi.util import get_remote_address

# Assuming 'request' is a valid request object
remote_address = get_remote_address(request)
```

--------------------------------

### Get IP Address from Request (SlowAPI)

Source: https://slowapi.readthedocs.io/en/latest/api

Retrieves the IP address of the current request, defaulting to '127.0.0.1' if not found. It relies on X-Forwarded-For headers. For more robust IP detection, consider using uvicorn's ProxyHeadersMiddleware.

```python
from slowapi.util import get_ipaddr

# Assuming 'request' is a valid request object
ip_address = get_ipaddr(request)
```

--------------------------------

### Initialize SlowApi Limiter

Source: https://slowapi.readthedocs.io/en/latest/api

Initializes the SlowApi rate limiter with various configuration options. It can be integrated with Starlette/FastAPI applications and supports custom limit definitions, storage backends, and error handling.

```Python
slowapi.extension.Limiter(
    key_func,
    default_limits=[],
    application_limits=[],
    headers_enabled=False,
    strategy=None,
    storage_uri=None,
    storage_options={},
    auto_check=True,
    swallow_errors=False,
    in_memory_fallback=[],
    in_memory_fallback_enabled=False,
    retry_after=None,
    key_prefix='',
    enabled=True,
    config_filename=None
)
```

--------------------------------

### Limit Wrapper Class

Source: https://slowapi.readthedocs.io/en/latest/api

A simple wrapper class to encapsulate rate limit details and their associated context, including the limit value, key function, scope, and other configuration parameters.

```Python
slowapi.wrappers.Limit(
    limit_,
    key_func_,
    scope_,
    per_method_,
    methods_,
    error_message_,
    exempt_when_,
    override_defaults_
)
```

--------------------------------

### Correct Decorator Order for Rate Limiting

Source: https://slowapi.readthedocs.io/en/latest/index

Shows the correct order of decorators when applying rate limits in FastAPI/Starlette. The '@limiter.limit' decorator should be placed below the route decorator to ensure the 'request' argument is available.

```python
@router.get("/test")
@limiter.limit("2/minute")
async def test(
    request: Request
):
return "hi"


```

--------------------------------

### Apply Shared Rate Limits

Source: https://slowapi.readthedocs.io/en/latest/api

A decorator for applying the same rate limit to multiple routes. It requires a scope to define the shared limit context and allows customization of the limit value, key function, and error handling.

```Python
shared_limit(
    limit_value,
    scope,
    key_func=None,
    error_message=None,
    exempt_when=None,
    override_defaults=True
)
```

--------------------------------

### LimitGroup Wrapper Class

Source: https://slowapi.readthedocs.io/en/latest/api

Represents a group of related rate limits, which can be defined by a string or a callable. This wrapper facilitates managing multiple limits and their shared context, including key functions and scopes.

```Python
slowapi.wrappers.LimitGroup(
    limit_provider_,
    key_function_,
    scope_,
    per_method_,
    methods_,
    error_message_,
    exempt_when_,
    override_defaults_
)
```

--------------------------------

### Ensure Request Argument for Rate Limiting

Source: https://slowapi.readthedocs.io/en/latest/index

Illustrates the requirement to explicitly pass the 'request' argument to endpoint functions when using SlowApi. This is necessary for the library to hook into the request context.

```python
@limiter.limit("5/minute")
async def myendpoint(request: Request)
    pass


```

--------------------------------

### Rate Limit Individual Routes

Source: https://slowapi.readthedocs.io/en/latest/api

A decorator to apply rate limiting to individual routes. It accepts a limit value, an optional key function for identifying unique limits, and parameters to control method-specific limits, error messages, and exemption conditions.

```Python
limit(
    limit_value,
    key_func=None,
    per_method=False,
    methods=None,
    error_message=None,
    exempt_when=None,
    override_defaults=True
)
```

--------------------------------

### Provide Response Object for Header Modification

Source: https://slowapi.readthedocs.io/en/latest/index

Explains how to provide the 'response' object explicitly to endpoint functions if the returned response is not a standard Response instance, allowing the Limiter to modify headers.

```python
@limiter.limit("5/minute")
async def myendpoint(request: Request, response: Response)
return {"key": "value"}


```
Tokens:
Raw