requests-cache

A persistent cache for python requests

62 个版本 Python >=3.8
Jordan Cook, Roman Haritonov
安装
pip install requests-cache
poetry add requests-cache
pipenv install requests-cache
conda install requests-cache
描述

Build Codecov Documentation Code Shelter

PyPI Conda Arch PyPI - Python Versions PyPI - Downloads

Summary

requests-cache is a persistent HTTP cache that provides an easy way to get better performance with the python requests library.

Complete project documentation can be found at requests-cache.readthedocs.io.

Features

  • Ease of use: Keep using the requests library you're already familiar with. Add caching with a drop-in replacement for requests.Session, or install globally to add transparent caching to all requests functions.
  • Performance: Get sub-millisecond response times for cached responses. When they expire, you still save time with conditional requests.
  • Persistence: Works with several storage backends including SQLite, Redis, MongoDB, and DynamoDB; or save responses as plain JSON files, YAML, and more
  • Expiration: Use Cache-Control and other standard HTTP headers, define your own expiration schedule, keep your cache clutter-free with backends that natively support TTL, or any combination of strategies
  • Customization: Works out of the box with zero config, but with a robust set of features for configuring and extending the library to suit your needs
  • Compatibility: Can be combined with other popular libraries based on requests

Quickstart

First, install with pip:

pip install requests-cache

Then, use requests_cache.CachedSession to make your requests. It behaves like a normal requests.Session, but with caching behavior.

To illustrate, we'll call an endpoint that adds a delay of 1 second, simulating a slow or rate-limited website.

This takes 1 minute:

import requests

session = requests.Session()
for i in range(60):
    session.get('https://httpbin.org/delay/1')

This takes 1 second:

import requests_cache

session = requests_cache.CachedSession('demo_cache')
for i in range(60):
    session.get('https://httpbin.org/delay/1')

With caching, the response will be fetched once, saved to demo_cache.sqlite, and subsequent requests will return the cached response near-instantly.

Patching

If you don't want to manage a session object, or just want to quickly test it out in your application without modifying any code, requests-cache can also be installed globally, and all requests will be transparently cached:

import requests
import requests_cache

requests_cache.install_cache('demo_cache')
requests.get('https://httpbin.org/delay/1')

Headers and Expiration

By default, requests-cache will keep cached responses indefinitely. In most cases, you will want to use one of the two following strategies to balance cache freshness and performance:

Define exactly how long to keep responses:

Use the expire_after parameter to set a fixed expiration time for all new responses:

from requests_cache import CachedSession
from datetime import timedelta

# Keep responses for 360 seconds
session = CachedSession('demo_cache', expire_after=360)

# Or use timedelta objects to specify other units of time
session = CachedSession('demo_cache', expire_after=timedelta(hours=1))

See Expiration for more features and settings.

Use Cache-Control headers:

Use the cache_control parameter to enable automatic expiration based on Cache-Control and other standard HTTP headers sent by the server:

from requests_cache import CachedSession

session = CachedSession('demo_cache', cache_control=True)

See Cache Headers for more details.

Settings

The default settings work well for most use cases, but there are plenty of ways to customize caching behavior when needed. Here is a quick example of some of the options available:

from datetime import timedelta
from requests_cache import CachedSession

session = CachedSession(
    'demo_cache',
    use_cache_dir=True,                # Save files in the default user cache dir
    cache_control=True,                # Use Cache-Control response headers for expiration, if available
    expire_after=timedelta(days=1),    # Otherwise expire responses after one day
    allowable_codes=[200, 400],        # Cache 400 responses as a solemn reminder of your failures
    allowable_methods=['GET', 'POST'], # Cache whatever HTTP methods you want
    ignored_parameters=['api_key'],    # Don't match this request param, and redact it from the cache
    match_headers=['Accept-Language'], # Cache a different response per language
    stale_if_error=True,               # In case of request errors, use stale cache data if possible
)

Next Steps

To find out more about what you can do with requests-cache, see:

版本列表
1.3.2 2026-05-11
1.3.1 2026-03-04
1.3.0 2026-02-02
1.3.0a1 2025-09-27
1.3.0a0 2025-02-25
1.2.1 2024-06-18
1.2.0 2024-02-17
1.1.1 2023-11-19
1.1.0 2023-06-30
1.0.1 2023-03-25
1.0.0 2023-03-02
1.0.0b1 2023-01-13
1.0.0b0 2022-09-29
1.0.0a2 2022-08-24
1.0.0a1 2022-06-12
1.0.0a0 2022-05-07
0.9.8 2023-01-13
0.9.7 2022-10-26
0.9.6 2022-08-24
0.9.5 2022-06-29
0.9.4 2022-04-23
0.9.3 2022-02-23
0.9.2 2022-02-15
0.9.1 2022-01-15
0.9.0 2022-01-01
0.8.1 2021-09-15
0.8.0 2021-09-07
0.7.5 2021-09-15
0.7.4 2021-08-16
0.7.3 2021-08-10
0.7.2 2021-07-21
0.7.1 2021-07-10
0.7.0 2021-07-07
0.6.4 2021-06-05
0.6.3 2021-04-21
0.6.2 2021-04-14
0.6.1 2021-04-13
0.6.0 2021-04-09
0.5.2 2019-08-14
0.5.1 2019-08-13
0.5.0 2019-04-18
0.4.13 2016-12-23
0.4.12 2016-03-19
0.4.11 2016-03-07
0.4.10 2015-04-28
0.4.9 2015-01-17
0.4.8 2014-12-13
0.4.7 2014-12-06
0.4.6 2014-10-13
0.4.5 2014-08-22
0.4.4 2013-10-31
0.4.3 2013-09-12
0.4.2 2013-08-25
0.4.1 2013-08-19
0.4.0 2013-04-25
0.3.0 2013-02-24
0.2.1 2013-01-13
0.2.0 2013-01-12
0.1.3 2012-05-04
0.1.2 2012-05-02
0.1.1 2012-04-11
0.1.0 2012-04-10