Warning: This library is intended for educational and personal use only. Please respect the terms of service of the websites being scraped and the applicable laws. The author is not responsible for any misuse.
Ani-Scrapy is a Python async-first library for scraping anime websites. It makes easy to switch between different platforms.
Ani-Scrapy helps developers automate anime downloads and build applications. It provides detailed anime and episode information, along with download links from multiple servers, supporting dynamic and static content across several sites.
- Async-First Design: Built from the ground up for asynchronous Python
- Multi-Platform Support: Unified interface for different platforms
- Comprehensive Data: Detailed anime metadata, episode information, and download links
- Static Content Extraction: Direct server links using
aiohttpandBeautifulSoup - Dynamic Content Processing: JavaScript-rendered links using
Playwright - Mixed Approach: Smart fallback between static and dynamic methods
- Concurrent Scraping: Built-in support for asynchronous batch processing
- Automatic Resource Management: Browser instances handled automatically
- Custom Browser Support: Configurable browser paths via
executable_path
- Modular Design: Easy to extend with new scrapers and platforms
- Logging: Uses Loguru; respects global configuration
- Performance Optimization: Connection reuse and caching capabilities
pip install ani-scrapy- Python >= 3.10.14
Install browser (only once):
playwright install chromiumRecommendation: Use Brave browser for sites with excessive advertising. See Custom Browser below.
Run the diagnostic tool to check your environment:
ani-scrapy doctorThis checks:
- Python version and platform
- Playwright and Chromium available
- Brave browser (recommended for sites with ads)
- Network connectivity to supported sites (AnimeFLV, JKAnime, AnimeAV1)
ani-scrapy doctor --output json # JSON output for CI/CD
ani-scrapy doctor --timeout 10 # Increase timeout for slow connections| Code | Meaning |
|---|---|
| 0 | All checks passed |
| 1 | Warnings found |
| 2 | Errors found |
Ani-Scrapy uses Loguru for all logging. By default, logging is silent (no output). To enable logging, use the enable_logging() function.
from ani_scrapy import AnimeFLVScraper, enable_logging
enable_logging(level="DEBUG") # Enable with DEBUG level to stdout
async with AnimeFLVScraper() as scraper:
await scraper.log("naruto")You can customize the log output:
from ani_scrapy import enable_logging
# Log to file
enable_logging(level="INFO", sink="ani_scrapy.log")
# Log to stdout with custom level
enable_logging(level="DEBUG", sink=None) # None = stdoutYou can configure a custom browser executable path. Brave is recommended because its native ad-blocker reduces blocking on sites with excessive advertisements, but any Chromium-based browser (Chrome, Chromium, Edge) will work.
- Native Ad-Block: Built-in protection reduces detection probability
- Avoids Captchas: Sites with aggressive ads may fail with Chromium's default configuration
- Better Success Rate: Sites with excessive advertising can fail or timeout with the default browser
from ani_scrapy import AnimeFLVScraper
brave_path = "C:/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe"
async with AnimeFLVScraper(executable_path=brave_path) as scraper:
info = await scraper.get_anime_info(anime_id="anime-id")For complete documentation: Docs index
search_anime- Search for animeget_anime_info- Get detailed anime informationget_table_download_links- Get direct server linksget_iframe_download_links- Get iframe linksget_file_download_link- Get final download URLget_new_episodes- Get new episodes since last known
AnimeFLVScraper- Scraper for AnimeFLVJKAnimeScraper- Scraper for JKAnimeAnimeAV1Scraper- Scraper for AnimeAV1
| Method | AnimeFLV | JKAnime | AnimeAV1 |
|---|---|---|---|
search_anime |
✅ Static | ✅ Static | ✅ Static |
get_anime_info |
✅ Static | ✅ Static | |
get_new_episodes |
✅ Static | ✅ Static | |
get_table_download_links |
✅ Static | ✅ Static | |
get_iframe_download_links |
✅ Static | ||
get_file_download_link |
Legend:
- ✅ Static: Method works without browser (HTTP only)
⚠️ Dynamic: Method requires browser (Playwright)
Test conditions: Anime "Gachiakuta", Episode 24, Query: "gach" (2026-04-12)
| Provider | search_anime | get_anime_info | get_table_download_links | get_iframe_download_links |
|---|---|---|---|---|
| AnimeFLV | 316.18 ms | 849.96 ms | 251.40 ms | 5070.68 ms |
| JKAnime | 468.76 ms | 30945.13 ms | 1661.44 ms | 8802.14 ms |
| AnimeAV1 | 517.24 ms | 355.09 ms | 298.78 ms | 299.14 ms |
AsyncBrowser- Manual browser control for advanced use cases
The library supports 3 ways to manage the browser for JavaScript-rendered content.
The browser is created automatically when needed and reused within the same context. Functions like get_anime_info, get_table_download_links, etc. will open the browser if not already open, or reuse it if another function already opened it within the same async with block:
import asyncio
from ani_scrapy import JKAnimeScraper
async def main():
async with JKAnimeScraper() as scraper:
# get_anime_info opens the browser internally
info = await scraper.get_anime_info("gachiakuta", include_episodes=True)
# get_table_download_links reuses the same browser
links = await scraper.get_table_download_links("gachiakuta", episode=1)
# Browser automatically closed when exiting context
asyncio.run(main())Use this pattern when you need explicit control over the browser lifecycle without using async with, or for programmatic usage. All functions in the scraper will use the same manually opened browser:
import asyncio
from ani_scrapy import JKAnimeScraper
async def scrape_anime(anime_id: str):
scraper = JKAnimeScraper()
await scraper.start_browser() # Open browser explicitly
# All functions use the same browser instance
info = await scraper.get_anime_info(anime_id, include_episodes=True)
links = await scraper.get_table_download_links(anime_id, episode=1)
final_url = await scraper.get_file_download_link(links.download_links[0])
await scraper.stop_browser() # Close browser explicitly
await scraper.aclose() # Close scraper resources
asyncio.run(scrape_anime("gachiakuta"))Use an externally created AsyncBrowser instance. All scraper functions will use the injected browser:
import asyncio
from ani_scrapy import AsyncBrowser, JKAnimeScraper
async def main():
# Create browser with custom executable
brave_path = "C:/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe"
async with AsyncBrowser(headless=True, executable_path=brave_path) as browser:
# Inject external browser into scraper
async with JKAnimeScraper(external_browser=browser) as scraper:
# All functions use the injected browser
info = await scraper.get_anime_info("gachiakuta")
print(f"Title: {info.title}")
# Browser stays open - controlled externally
asyncio.run(main())| Pattern | Use Case |
|---|---|
| 1. Automatic | Most cases - simple and automatic |
| 2. Manual | Programmatic use without async with, fine-grained control |
| 3. External | Share browser across scrapers, custom browser config |
import asyncio
async def scrape_multiple_animes(anime_ids, scraper):
tasks = []
for anime_id in anime_ids:
task = scraper.get_anime_info(anime_id)
tasks.append(task)
results = await asyncio.gather(*tasks, return_exceptions=True)
return resultsMIT © 2025 El Pitágoras