Downloader Middleware

The downloader middleware is a framework of hooks into Scrapy’s request/response processing. It’s a light, low-level system for globally altering Scrapy’s requests and responses.

Activating a downloader middleware

To activate a downloader middleware component, add it to the DOWNLOADER_MIDDLEWARES setting, which is a dict whose keys are the middleware class paths and their values are the middleware orders.

Here’s an example:

    'myproject.middlewares.CustomDownloaderMiddleware': 543,

The DOWNLOADER_MIDDLEWARES setting is merged with the DOWNLOADER_MIDDLEWARES_BASE setting defined in Scrapy (and not meant to be overridden) and then sorted by order to get the final sorted list of enabled middlewares: the first middleware is the one closer to the engine and the last is the one closer to the downloader.

To decide which order to assign to your middleware see the DOWNLOADER_MIDDLEWARES_BASE setting and pick a value according to where you want to insert the middleware. The order does matter because each middleware performs a different action and your middleware could depend on some previous (or subsequent) middleware being applied.

If you want to disable a built-in middleware (the ones defined in DOWNLOADER_MIDDLEWARES_BASE and enabled by default) you must define it in your project’s DOWNLOADER_MIDDLEWARES setting and assign None as its value. For example, if you want to disable the off-site middleware:

    'myproject.middlewares.CustomDownloaderMiddleware': 543,
    'scrapy.contrib.downloadermiddleware.useragent.UserAgentMiddleware': None,

Finally, keep in mind that some middlewares may need to be enabled through a particular setting. See each middleware documentation for more info.

Writing your own downloader middleware

Writing your own downloader middleware is easy. Each middleware component is a single Python class that defines one or more of the following methods:

class scrapy.contrib.downloadermiddleware.DownloaderMiddleware
process_request(request, spider)

This method is called for each request that goes through the download middleware.

process_request() should return either None, a Response object, or a Request object.

If it returns None, Scrapy will continue processing this request, executing all other middlewares until, finally, the appropriate downloader handler is called the request performed (and its response downloaded).

If it returns a Response object, Scrapy won’t bother calling ANY other request or exception middleware, or the appropriate download function; it’ll return that Response. Response middleware is always called on every Response.

If it returns a Request object, the returned request will be rescheduled (in the Scheduler) to be downloaded in the future. The callback of the original request will always be called. If the new request has a callback it will be called with the response downloaded, and the output of that callback will then be passed to the original callback. If the new request doesn’t have a callback, the response downloaded will be just passed to the original request callback.

If it returns an IgnoreRequest exception, the entire request will be dropped completely and its callback never called.

  • request (Request object) – the request being processed
  • spider (BaseSpider object) – the spider for which this request is intended
process_response(request, response, spider)

process_response() should return a Response object or raise a IgnoreRequest exception.

If it returns a Response (it could be the same given response, or a brand-new one), that response will continue to be processed with the process_response() of the next middleware in the pipeline.

If it returns an IgnoreRequest exception, the response will be dropped completely and its callback never called.

  • request (is a Request object) – the request that originated the response
  • reponse – the response being processed
  • spider (BaseSpider object) – the spider for which this response is intended
process_download_exception(request, exception, spider)

Scrapy calls process_download_exception() when a download handler or a process_request() (from a downloader middleware) raises an exception.

process_download_exception() should return either None, Response or Request object.

If it returns None, Scrapy will continue processing this exception, executing any other exception middleware, until no middleware is left and the default exception handling kicks in.

If it returns a Response object, the response middleware kicks in, and won’t bother calling any other exception middleware.

If it returns a Request object, the returned request is used to instruct an immediate redirection. The original request won’t finish until the redirected request is completed. This stops the process_download_exception() middleware the same as returning Response would do.

  • request (is a Request object) – the request that generated the exception
  • exception (an Exception object) – the raised exception
  • spider (BaseSpider object) – the spider for which this request is intended

Built-in downloader middleware reference

This page describes all downloader middleware components that come with Scrapy. For information on how to use them and how to write your own downloader middleware, see the downloader middleware usage guide.

For a list of the components enabled by default (and their orders) see the DOWNLOADER_MIDDLEWARES_BASE setting.


class scrapy.contrib.downloadermiddleware.cookies.CookiesMiddleware

This middleware enables working with sites that need cookies.


class scrapy.contrib.downloadermiddleware.defaultheaders.DefaultHeadersMiddleware

This middleware sets all default requests headers specified in the DEFAULT_REQUEST_HEADERS setting.


class scrapy.contrib.downloadermiddleware.httpauth.HttpAuthMiddleware

This middleware authenticates all requests generated from certain spiders using Basic access authentication (aka. HTTP auth).

To enable HTTP authentication from certain spiders, set the http_user and http_pass attributes of those spiders.


class SomeIntranetSiteSpider(CrawlSpider):

    http_user = 'someuser'
    http_pass = 'somepass'
    name = ''

    # .. rest of the spider code omitted ...


class scrapy.contrib.downloadermiddleware.httpcache.HttpCacheMiddleware

This middleware provides low-level cache to all HTTP requests and responses. Every request and its corresponding response are cached. When the same request is seen again, the response is returned without transferring anything from the Internet.

The HTTP cache is useful for testing spiders faster (without having to wait for downloads every time) and for trying your spider offline, when you don’t have an Internet connection.

File system storage

By default, the HttpCacheMiddleware uses a file system storage with the following structure:

Each request/response pair is stored in a different directory containing the following files:

  • request_body - the plain request body
  • request_headers - the request headers (in raw HTTP format)
  • response_body - the plain response body
  • response_headers - the request headers (in raw HTTP format)
  • meta - some metadata of this cache resource in Python repr() format (grep-friendly format)
  • pickled_meta - the same metadata in meta but pickled for more efficient deserialization

The directory name is made from the request fingerprint (see scrapy.utils.request.fingerprint), and one level of subdirectories is used to avoid creating too many files into the same directory (which is inefficient in many file systems). An example directory could be:


The cache storage backend can be changed with the HTTPCACHE_STORAGE setting, but no other backend is provided with Scrapy yet.


The HttpCacheMiddleware can be configured through the following settings:


Default: '' (empty string)

The directory to use for storing the (low-level) HTTP cache. If empty, the HTTP cache will be disabled.


Default: 0

Number of seconds to use for HTTP cache expiration. Requests that were cached before this time will be re-downloaded. If zero, cached requests will always expire. A negative number means requests will never expire.


Default: False

If enabled, requests not found in the cache will be ignored instead of downloaded.


Default: 'scrapy.contrib.downloadermiddleware.httpcache.FilesystemCacheStorage'

The class which implements the cache storage backend.


class scrapy.contrib.downloadermiddleware.httpcompression.HttpCompressionMiddleware

This middleware allows compressed (gzip, deflate) traffic to be sent/received from web sites.


New in version 0.8.

class scrapy.contrib.downloadermiddleware.httpproxy.HttpProxyMiddleware

This middleware sets the HTTP proxy to use for requests, by setting the proxy meta value to Request objects.

Like the Python standard library modules urllib and urllib2, it obeys the following enviroment variables:

  • http_proxy
  • https_proxy
  • no_proxy


class scrapy.contrib.downloadermiddleware.redirect.RedirectMiddleware

This middlware handles redirection of requests based on response status and meta-refresh html tag.

The RedirectMiddleware can be configured through the following settings (see the settings documentation for more info):


class scrapy.contrib.downloadermiddleware.retry.RetryMiddleware

A middlware to retry failed requests that are potentially caused by temporary problems such as a connection timeout or HTTP 500 error.

Failed pages are collected on the scraping process and rescheduled at the end, once the spider has finished crawling all regular (non failed) pages. Once there are no more failed pages to retry, this middleware sends a signal (retry_complete), so other extensions could connect to that signal.

The RetryMiddleware can be configured through the following settings (see the settings documentation for more info):

  • RETRY_TIMES - how many times to retry a failed page
  • RETRY_HTTP_CODES - which HTTP response codes to retry

About HTTP errors to consider:

You may want to remove 400 from RETRY_HTTP_CODES, if you stick to the HTTP protocol. It’s included by default because it’s a common code used to indicate server overload, which would be something we want to retry.


class scrapy.contrib.downloadermiddleware.robotstxt.RobotsTxtMiddleware

This middleware filters out requests forbidden by the robots.txt exclusion standard.

To make sure Scrapy respects robots.txt make sure the middleware is enabled and the ROBOTSTXT_OBEY setting is enabled.


Keep in mind that, if you crawl using multiple concurrent requests per domain, Scrapy could still download some forbidden pages if they were requested before the robots.txt file was downloaded. This is a known limitation of the current robots.txt middleware and will be fixed in the future.


class scrapy.contrib.downloadermiddleware.stats.DownloaderStats

Middleware that stores stats of all requests, responses and exceptions that pass through it.

To use this middleware you must enable the DOWNLOADER_STATS setting.


class scrapy.contrib.downloadermiddleware.useragent.UserAgentMiddleware

Middleware that allows spiders to override the default user agent.

In order for a spider to override the default user agent, its user_agent attribute must be set.