awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
rmax avatar

rmax/scrapy-redis

0
View on GitHub↗
5,639 stars·1,581 forks·Python·MIT·30 viewsscrapy-redis.readthedocs.io↗

Scrapy Redis

Scrapy-Redis is a library that transforms Scrapy into a distributed web crawling framework by replacing its in-memory scheduler with a Redis-backed component. This allows multiple Scrapy spider workers to coordinate through a shared request queue, enabling them to consume URLs concurrently while a Redis set tracks seen URLs across all workers to prevent duplicate crawls. The system persists crawl state—including pending requests and already-crawled URLs—in Redis, so a paused or crashed spider can resume from where it left off without losing progress.

The library provides a Redis-based duplicate filter that deduplicates URLs across distributed crawls, and a Redis item pipeline that pushes scraped items into a Redis queue for asynchronous consumption by downstream processors. It supports dynamic injection of crawl targets by reading structured JSON payloads from Redis and converting them into HTTP requests with associated metadata and cookies, allowing external processes to feed new URLs into the shared queue while spiders consume them in real time. Configuration is handled through standard Redis connection parameters such as host, port, or connection URL.

The project covers the full lifecycle of distributed web crawling: request scheduling and distribution, URL deduplication, crawl state persistence, and scraped item queuing. It replaces Scrapy's built-in scheduler, dupefilter, and item pipeline with Redis-backed equivalents, making it straightforward to scale crawling across multiple machines.

Features

  • Distributed Crawl Coordination - Coordinates multiple Scrapy spiders that share a Redis-backed request queue and deduplicate URLs across workers.
  • Redis-Backed Schedulers - Replaces Scrapy's in-memory scheduler with a Redis-backed one that coordinates request distribution across workers.
  • Redis - Pushes scraped data into Redis queues for downstream batch processing or consumption by separate services.
  • Web Crawl Schedulers - Implements a distributed scheduler that coordinates crawl request distribution across multiple Scrapy spider workers via Redis.
  • Scraped Item Sinks - Pushes scraped items into a Redis list for asynchronous consumption by downstream processors.
  • Scraped Data Storage - Persists each scraped item into a Redis list for later batch processing or consumption by other services.
  • Redis Item Queues - Pushes scraped items into a Redis queue so separate processes can consume and process them independently.
  • Visited URL Sets - Uses a Redis set to track seen URLs across all workers, preventing duplicate crawls.
  • Distributed Job Execution - Shares a Redis-backed request queue among multiple spider instances so each worker picks the next unprocessed URL.
  • Crawl Request Schedulers - Pushes new URLs into a Redis list and lets any connected spider consume them, enabling dynamic feed-in of crawl targets.
  • Crawl State Recovery - Saves crawled URLs and pending requests in Redis to survive restarts and enable resume.
  • Redis-Backed Queues - Stores pending crawl requests in Redis lists so multiple spiders can consume them concurrently.
  • Crawl Request Injectors - Reads JSON payloads from Redis and converts them into structured HTTP requests with metadata and cookies.
  • Crawl Request Queues - Provides a Redis-backed queue that stores and distributes HTTP crawl requests across multiple Scrapy spider workers.
  • URL Duplicate Filters - Ships a Redis-based duplicate filter that prevents the same URL from being crawled twice across distributed spider workers.
  • Crawl Request Injections - Reads JSON payloads from Redis and converts them into structured HTTP requests with metadata and cookies.
  • Crawl Request Deduplications - Uses a Redis set to filter duplicate URLs across all running spiders, preventing the same page from being crawled twice.
  • Dynamic URL Injections - Feeds new crawl targets into a shared Redis queue from external processes while spiders consume them in real time.

Star history

Star history chart for rmax/scrapy-redisStar history chart for rmax/scrapy-redis

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Projects sharing features with Scrapy Redis

These projects share indexed features with Scrapy Redis. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • rolando/scrapy-redisrolando avatar

    rolando/scrapy-redis

    5,639View on GitHub↗

    This project is a distributed web crawling framework that enables the horizontal scaling of scraping tasks. It uses Redis as a centralized request queue manager and state store to coordinate crawl progress and request metadata across multiple server instances. The system distributes crawling workloads by sharing a single request queue and utilizes a distributed duplicate filter to prevent multiple workers from visiting the same page. It persists complex request state and metadata as JSON strings within the shared remote store. The framework also provides capabilities for distributed data pro

    Python
    View on GitHub↗5,639
  • taskforcesh/bullmqtaskforcesh avatar

    taskforcesh/bullmq

    8,432View on GitHub↗

    BullMQ is a Redis-backed message queue library and background processor designed for distributed task queueing. It functions as a distributed queue manager and task scheduler, utilizing Redis to manage asynchronous job processing and persistence. The system distinguishes itself through its role as a job workflow orchestrator, enabling the definition of complex parent-child job dependencies and hierarchies for multi-step workflows. It provides sandboxed process execution to isolate heavy workloads and prevent event loop blocking, alongside distributed rate limiting to protect downstream servic

    TypeScriptbackground-jobselixirnodejs
    View on GitHub↗8,432
  • contribsys/faktorycontribsys avatar

    contribsys/faktory

    6,089View on GitHub↗

    Faktory is an open-source work server that queues, dispatches, and manages background jobs across multiple programming languages. It stores job payloads as JSON hashes in a Redis-backed queue and provides language-specific client and worker libraries that enable any language to push jobs to the server or fetch and execute them. The server includes a batch workflow orchestrator that groups jobs into batches with completion tracking for coordinating multi-step asynchronous workflows. It features a configurable job uniqueness filter that prevents duplicate enqueues within a time window, an expon

    Go
    View on GitHub↗6,089
  • henrylee2cn/pholcushenrylee2cn avatar

    henrylee2cn/pholcus

    7,578View on GitHub↗

    Pholcus is a distributed web crawler framework written in Go designed for high-concurrency data extraction. It functions as a distributed crawling orchestrator and dynamic data extraction engine, utilizing a server-client architecture to coordinate tasks across multiple nodes. The system integrates a headless browser engine to render dynamic content and execute JavaScript, allowing it to extract data from single-page applications. It features a web-based management interface for configuring spider parameters and monitoring execution progress, alongside the ability to update extraction rules v

    Go
    View on GitHub↗7,578
Compare all 30 related projects→

Frequently asked questions

What does rmax/scrapy-redis do?

Scrapy-Redis is a library that transforms Scrapy into a distributed web crawling framework by replacing its in-memory scheduler with a Redis-backed component. This allows multiple Scrapy spider workers to coordinate through a shared request queue, enabling them to consume URLs concurrently while a Redis set tracks seen URLs across all workers to prevent duplicate crawls. The system persists crawl state—including pending requests and already-crawled URLs—in Redis, so a…

What are the main features of rmax/scrapy-redis?

The main features of rmax/scrapy-redis are: Distributed Crawl Coordination, Redis-Backed Schedulers, Redis, Web Crawl Schedulers, Scraped Item Sinks, Scraped Data Storage, Redis Item Queues, Visited URL Sets.

Which projects share features with rmax/scrapy-redis?

Projects with overlapping indexed features include: rolando/scrapy-redis — This project is a distributed web crawling framework that enables the horizontal scaling of scraping tasks. It uses… taskforcesh/bullmq — BullMQ is a Redis-backed message queue library and background processor designed for distributed task queueing. It… contribsys/faktory — Faktory is an open-source work server that queues, dispatches, and manages background jobs across multiple programming… henrylee2cn/pholcus — Pholcus is a distributed web crawler framework written in Go designed for high-concurrency data extraction. It… j3ssie/osmedeus — Osmedeus is a security workflow orchestration engine that coordinates AI agents, shell commands, and scanning tools… optimalbits/bull — Bull is a Node.js library for managing distributed jobs and message queues using Redis as the primary data store. It…