AnimeParsers

https://github.com/yanesytortik/animeparsers
Admin
This project provides a wide range of Python parsers for various anime players in the...
Tokens:7,775
Snippets:32
Trust Score:6.9
License:MIT
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install AnimeParsers with Pip

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Installs the anime-parsers-ru package using pip. Options include installing with lxml for faster parsing or with async support using aiohttp.

```bash
# Standard installation
pip install anime-parsers-ru

# With lxml for faster parsing
pip install anime-parsers-ru[lxml]

# With async support (aiohttp)
pip install anime-parsers-ru[async]
```

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

### ShikimoriParser - Get Anime List with Filters

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Retrieves filtered anime lists from Shikimori using various criteria. This example demonstrates initializing the parser and preparing to fetch lists, though specific filtering parameters are not shown in the provided snippet.

```python
from anime_parsers_ru import ShikimoriParser

parser = ShikimoriParser()

```

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

### JutsuParser - Get Anime Info

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Parses and retrieves detailed information about an anime from JutSu, given its URL.

```APIDOC
## GET /jutsu/anime_info

### Description
Parses and retrieves detailed information about an anime from JutSu, given its URL.

### Method
GET

### Endpoint
/jutsu/anime_info

### Parameters
#### Query Parameters
- **url** (string) - Required - The URL of the anime page on JutSu (e.g., "https://jut.su/ookami-to-koshinryou/").

### Request Example
```python
# Example usage (not a direct API call)
info = parser.get_anime_info("https://jut.su/ookami-to-koshinryou/")

print(f"Title: {info['title']}")
print(f"Original: {info['original_title']}")
print(f"Age Rating: {info['age_rating']}")
print(f"Years: {', '.join(info['years'])}")
print(f"Genres: {', '.join(info['genres'])}")
print(f"Seasons: {len(info['seasons'])}")
```

### Response
#### Success Response (200)
- **anime_info** (object) - An object containing anime details, including:
  - **title** (string) - The title of the anime.
  - **original_title** (string) - The original title of the anime.
  - **age_rating** (string) - The age rating of the anime.
  - **description** (string) - A description of the anime.
  - **years** (array) - The release years of the anime.
  - **genres** (array) - The genres associated with the anime.
  - **poster** (string) - The URL of the anime's poster.
  - **seasons** (array) - A list of seasons, where each season is a list of episode URLs.
  - **seasons_names** (array) - The names of the seasons.
  - **films** (array) - URLs for any associated films.
```

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

### Get Ongoing Anime List with ShikimoriParser

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Fetches a list of ongoing anime from Shikimori based on specified criteria such as type, rating, genres, and sorting. It then iterates through the results to print the title, year, type, and URL of each anime.

```python
from anime_parsers_ru import ShikimoriParser

parser = ShikimoriParser()

# Get ongoing anime
ongoing = parser.get_anime_list(
    status=["ongoing"],
    anime_type=["tv"],
    rating="pg_13",  # Options: g, pg, pg_13, r, r_plus
    genres=["10-Fantasy", "22-Romance"],
    start_page=1,
    page_limit=3,
    sort_by="rating"  # Options: rating, popularity, name, aired_on, ranked_random, id_desc
)

for anime in ongoing:
    print(f"{anime['title']} ({anime['year']}) - {anime['type']}")
    print(f"  URL: {anime['url']}")

# Helper functions
link = parser.link_by_id("53446")  # Get Shikimori URL from ID
anime_id = parser.id_by_link("https://shikimori.one/animes/53446-tondemo-skill")  # Extract ID
```

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

### JutsuParser - Get MP4 Video Links

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Retrieves direct MP4 video links for a specific episode from JutSu.

```APIDOC
## GET /jutsu/mp4_links

### Description
Retrieves direct MP4 video links for a specific episode from JutSu.

### Method
GET

### Endpoint
/jutsu/mp4_links

### Parameters
#### Query Parameters
- **url** (string) - Required - The URL of the episode page on JutSu (e.g., "https://jut.su/ookami-to-koshinryou/episode-1.html").

### Request Example
```python
# Example usage (not a direct API call)
mp4_links = parser.get_mp4_link("https://jut.su/ookami-to-koshinryou/episode-1.html")

# Output: {"360": "https://...", "480": "https://...", "720": "https://...", "1080": "https://..."}
for quality, url in mp4_links.items():
    print(f"  {quality}p: {url}")
```

### Response
#### Success Response (200)
- **mp4_links** (object) - An object where keys are video qualities (e.g., "360", "480", "720", "1080") and values are the corresponding MP4 video URLs.
```

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

### AniboomParser - Search and Get Anime Info

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Parses anime from AniBoom player via animego.me without requiring an API key. It supports fast and extended searches, retrieving detailed anime information, and listing available translations.

```python
from anime_parsers_ru import AniboomParser

parser = AniboomParser()
# Use mirror if original domain is blocked:
# parser = AniboomParser(mirror="animego-mirror.com")

# Fast search (basic info)
results = parser.fast_search("Spice and Wolf")

# Output:
# [
#     {
#         "title": "Spice and Wolf",
#         "year": "2024",
#         "other_title": "Ookami to Koushinryou",
#         "type": "TV Series",
#         "link": "https://animego.me/anime/...",
#         "animego_id": "2546"
#     }
# ]

# Extended search with full details
full_results = parser.search("Spice and Wolf")

# Get detailed anime info directly
info = parser.anime_info("https://animego.me/anime/spice-and-wolf-2546")

print(f"Title: {info['title']}")
print(f"Status: {info['status']}")
print(f"Episodes: {info['episodes']}")
print(f"Genres: {', '.join(info['genres'])}")
print(f"Description: {info['description'][:200]}...")

# Get available translations
translations = parser.get_translations_info("2546")
for trans in translations:
    print(f"  {trans['name']} - ID: {trans['translation_id']}")
```

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

### ShikimoriParser - Get Anime Info by ID (GraphQL)

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Fetches detailed information for a specific anime using its Shikimori ID via GraphQL.

```APIDOC
## GET /shikimori/anime/{shikimori_id}

### Description
Fetches detailed information for a specific anime using its Shikimori ID via GraphQL.

### Method
GET

### Endpoint
/shikimori/anime/{shikimori_id}

### Parameters
#### Path Parameters
- **shikimori_id** (string) - Required - The unique ID of the anime on Shikimori.

#### Query Parameters
- **return_parameters** (array) - Optional - A list of fields to return for the anime (e.g., "id", "name", "airedOn { year }", "studios { name }").

### Request Example
```python
# Example usage (not a direct API call)
info = parser.deep_anime_info(
    shikimori_id="53446",
    return_parameters=[
        "id",
        "name",
        "russian",
        "score",
        "episodes",
        "airedOn { year month day }",
        "releasedOn { date }",
        "genres { id russian kind }",
        "studios { name imageUrl }",
        "screenshots { originalUrl }",
        "description"
    ]
)

print(f"Anime: {info['russian']}")
print(f"Aired: {info['airedOn']['year']}")
```

### Response
#### Success Response (200)
- **anime_info** (object) - An object containing detailed information about the anime, with fields specified in `return_parameters`.
```

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

### AniboomParser - Get MPD Playlist

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Obtains MPD (DASH) playlist content for streaming or conversion and allows saving it directly to a file. It also retrieves episode information for a given anime.

```python
from anime_parsers_ru import AniboomParser

parser = AniboomParser()

# Get MPD playlist content as string
mpd_content = parser.get_mpd_playlist(
    animego_id="2546",        # From search results
    episode=1,                # Episode number (0 for movies)
    translation_id="12345"    # From get_translations_info()
)

# Save MPD file directly
parser.get_as_file(
    animego_id="2546",
    episode=1,
    translation_id="12345",
    filename="episode.mpd"
)

# Play with VLC or convert with ffmpeg:
# vlc episode.mpd
# ffmpeg -i episode.mpd -c copy output.mp4

# Get episode information
episodes = parser.episodes_info("https://animego.me/anime/spice-and-wolf-2546")

for ep in episodes:
    print(f"Episode {ep['num']}: {ep['title']} ({ep['status']})")
```

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

### Advanced Search with ShikimoriParser GraphQL API

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Performs an advanced search using Shikimori's GraphQL API with custom parameters for title, limit, kind, status, rating, order, and censorship. It also specifies the return parameters to get detailed information about the anime.

```python
from anime_parsers_ru import ShikimoriParser

parser = ShikimoriParser()

# Deep search with custom parameters
results = parser.deep_search(
    title="Culinary Adventures",
    search_parameters={
        "limit": 5,
        "kind": "tv",
        "status": "released",
        "rating": "pg_13",
        "order": "ranked",
        "censored": False  # Allow 18+ content
    },
    return_parameters=[
        "id",
        "name",
        "russian",
        "score",
        "status",
        "episodes",
        "rating",
        "poster { originalUrl }",
        "genres { russian }",
        "studios { name }",
        "description"
    ]
)

for anime in results:
    print(f"{anime['russian']} ({anime['name']})")
    print(f"  Score: {anime['score']}")
    print(f"  Episodes: {anime['episodes']}")
    if anime.get('studios'):
        print(f"  Studio: {anime['studios'][0]['name']}")

# Get detailed info by ID using GraphQL
info = parser.deep_anime_info(
    shikimori_id="53446",
    return_parameters=[
        "id",
        "name",
        "russian",
        "score",
        "episodes",
        "airedOn { year month day }",
        "releasedOn { date }",
        "genres { id russian kind }",
        "studios { name imageUrl }",
        "screenshots { originalUrl }",
        "description"
    ]
)

print(f"Anime: {info['russian']}")
print(f"Aired: {info['airedOn']['year']}")
```

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

### ShikimoriParser - Get Ongoing Anime

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Retrieves a list of ongoing anime with specified filters such as type, rating, genres, and sorting options.

```APIDOC
## GET /anime/ongoing

### Description
Retrieves a list of ongoing anime with specified filters such as type, rating, genres, and sorting options.

### Method
GET

### Endpoint
/anime/ongoing

### Parameters
#### Query Parameters
- **status** (array) - Optional - Filter by anime status (e.g., "ongoing").
- **anime_type** (array) - Optional - Filter by anime type (e.g., "tv").
- **rating** (string) - Optional - Filter by age rating (e.g., "pg_13").
- **genres** (array) - Optional - Filter by genres (e.g., ["10-Fantasy", "22-Romance"]).
- **start_page** (integer) - Optional - The starting page number for pagination.
- **page_limit** (integer) - Optional - The maximum number of results per page.
- **sort_by** (string) - Optional - The field to sort the results by (e.g., "rating", "popularity").

### Response
#### Success Response (200)
- **anime** (array) - A list of anime objects, each containing:
  - **title** (string) - The title of the anime.
  - **year** (integer) - The release year of the anime.
  - **type** (string) - The type of the anime (e.g., "tv").
  - **url** (string) - The URL to the anime's page.

### Request Example
```python
# Example usage (not a direct API call)
ongoing = parser.get_anime_list(
    status=["ongoing"],
    anime_type=["tv"],
    rating="pg_13",
    genres=["10-Fantasy", "22-Romance"],
    start_page=1,
    page_limit=3,
    sort_by="rating"
)

for anime in ongoing:
    print(f"{anime['title']} ({anime['year']}) - {anime['type']}")
    print(f"  URL: {anime['url']}")
```
```

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

### ShikimoriParser - Search and Get Anime Info

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Parses anime metadata from the Shikimori anime database without an API key. It supports quick searches, retrieving detailed anime information, and fetching additional data like related anime and characters.

```python
from anime_parsers_ru import ShikimoriParser
import time

parser = ShikimoriParser()
# Use mirror if blocked:
# parser = ShikimoriParser(mirror="shikimori-mirror.com")

# Quick search
results = parser.search("Naruto")

for anime in results:
    print(f"{anime['title']} ({anime['year']}) - {anime['type']}")
    print(f"  Status: {anime['status']}")
    print(f"  Genres: {', '.join(anime['genres'])}")
    print(f"  ID: {anime['shikimori_id']}")

# Get detailed anime info
# Note: Add 1-3 second delay between requests to avoid rate limiting
time.sleep(1)

info = parser.anime_info(results[0]['link'])

print(f"Title: {info['title']}")
print(f"Score: {info['score']}")
print(f"Episodes: {info['episodes']}")
print(f"Description: {info['description'][:300]}...")

# Get additional info (related anime, characters, screenshots)
time.sleep(1)
additional = parser.additional_anime_info(results[0]['link'])

print("Related anime:")
for related in additional['related'][:5]:
    print(f"  {related['name']} - {related['relation']}")

print("Main characters:")
for char in additional['main_characters'][:5]:
    print(f"  {char['name']}")
```

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

### KodikParser: Get Direct Video Links (Python)

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Obtains direct video file URLs and m3u8 playlist links for anime streaming. Supports specifying episode number, translation ID, and quality. Requires a Kodik API token.

```python
from anime_parsers_ru import KodikParser

parser = KodikParser(token="your_kodik_api_token")

# Get direct video link
link, max_quality = parser.get_link(
    id="20",              # Shikimori ID
    id_type="shikimori",
    seria_num=1,          # Episode number (0 for movies)
    translation_id="609"  # AniDUB translation ID
)

# Output: ("//cloud.kodik-storage.com/.../", 720)
# Full URL: https://cloud.kodik-storage.com/.../720.mp4

print(f"Video URL: https:{link}720.mp4")
print(f"Max quality: {max_quality}p")

# Get m3u8 playlist link for HLS streaming
playlist_url = parser.get_m3u8_playlist_link(
    id="20",
    id_type="shikimori",
    seria_num=1,
    translation_id="609",
    quality=720  # Options: 360, 480, 720
)

# Output: https://cloud.kodik-storage.com/.../720.mp4:hls:manifest.m3u8

# Get m3u8 playlist content (for local playback with VLC, etc.)
playlist_content = parser.get_m3u8_playlist(
    id="20",
    id_type="shikimori",
    seria_num=1,
    translation_id="609",
    quality=480
)

# Save playlist for local use
with open("episode.m3u8", "w") as f:
    f.write(playlist_content)
```

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

### Get Anime Info and Video Links with JutsuParser

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Parses anime information from the JutSu streaming service, including title, original title, age rating, years, genres, and poster URL. It can also retrieve direct MP4 links for specific episodes across different quality settings.

```python
from anime_parsers_ru import JutsuParser

parser = JutsuParser()
# Use mirror if blocked:
# parser = JutsuParser(mirror="jutsu-mirror.com")

# Get anime info (use original title in URL format)
# Example: "Spice and Wolf" -> "ookami-to-koshinryou"
info = parser.get_anime_info("https://jut.su/ookami-to-koshinryou/")

print(f"Title: {info['title']}")
print(f"Original: {info['original_title']}")
print(f"Age Rating: {info['age_rating']}")
print(f"Years: {', '.join(info['years'])}")
print(f"Genres: {', '.join(info['genres'])}")
print(f"Seasons: {len(info['seasons'])}")

# Output structure:
# {
#     "title": "Anime Title",
#     "original_title": "Original Title",
#     "age_rating": "16+",
#     "description": "...",
#     "years": ["2024"],
#     "genres": ["Fantasy", "Romance"],
#     "poster": "https://...",
#     "seasons": [["ep1_url", "ep2_url"], ["s2ep1_url"]],
#     "seasons_names": ["Season 1", "Season 2"],
#     "films": ["film1_url", "film2_url"]
# }

# Get direct MP4 links for an episode
mp4_links = parser.get_mp4_link("https://jut.su/ookami-to-koshinryou/episode-1.html")

# Output: {"360": "https://...", "480": "https://...", "720": "https://...", "1080": "https://..."}
for quality, url in mp4_links.items():
    print(f"  {quality}p: {url}")

# Download example with requests
import requests
best_quality = max(mp4_links.keys(), key=int)
video_url = mp4_links[best_quality]
# response = requests.get(video_url, stream=True)
```

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

### Async Parsers - General Usage

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Demonstrates the asynchronous usage of Kodik, AniBoom, and Shikimori parsers for non-blocking operations.

```APIDOC
## Async API Operations

### Description
Provides asynchronous versions of parsers for efficient handling of multiple requests without blocking.

### Methods
- **KodikParserAsync**: For interacting with the Kodik service.
- **AniboomParserAsync**: For interacting with the AniBoom service.
- **ShikimoriParserAsync**: For interacting with the Shikimori service.

### Usage Example
```python
import asyncio
from anime_parsers_ru import KodikParserAsync, AniboomParserAsync, ShikimoriParserAsync

async def main():
    # Async Kodik Parser Example
    kodik = KodikParserAsync(token="your_token")
    results = await kodik.search("Naruto", limit=5)

    link, quality = await kodik.get_link(
        id="20",
        id_type="shikimori",
        seria_num=1,
        translation_id="609"
    )

    # Async AniBoom Parser Example
    aniboom = AniboomParserAsync()
    anime_list = await aniboom.fast_search("Spice and Wolf")
    info = await aniboom.anime_info(anime_list[0]['link'])

    # Async Shikimori Parser Example
    shiki = ShikimoriParserAsync()
    search_results = await shiki.search("Naruto")

    # Using KodikSearch for async execution
    from anime_parsers_ru import KodikSearch
    query = KodikSearch(token="your_token").title("Overlord").limit(5)
    response = await query.execute_async()

    return results, info, search_results

# Run async code
# asyncio.run(main())
```

### Response
#### Success Response (200)
Responses vary based on the specific parser and method called (e.g., search results, anime info, video links).
```

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

### Asynchronous Anime Parsing with Kodik, AniBoom, and Shikimori

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Demonstrates the use of asynchronous parsers for Kodik, AniBoom, and Shikimori. It shows how to perform searches, retrieve anime links, and fetch detailed anime information asynchronously using Python's asyncio library.

```python
import asyncio
from anime_parsers_ru import KodikParserAsync, AniboomParserAsync, ShikimoriParserAsync

async def main():
    # Async Kodik Parser
    kodik = KodikParserAsync(token="your_token")
    results = await kodik.search("Naruto", limit=5)

    link, quality = await kodik.get_link(
        id="20",
        id_type="shikimori",
        seria_num=1,
        translation_id="609"
    )

    # Async AniBoom Parser
    aniboom = AniboomParserAsync()
    anime_list = await aniboom.fast_search("Spice and Wolf")
    info = await aniboom.anime_info(anime_list[0]['link'])

    # Async Shikimori Parser
    shiki = ShikimoriParserAsync()
    search_results = await shiki.search("Naruto")

    # With async Kodik API
    from anime_parsers_ru import KodikSearch
    query = KodikSearch(token="your_token").title("Overlord").limit(5)
    response = await query.execute_async()

    return results, info, search_results

# Run async code
results = asyncio.run(main())
```

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

### Kodik Search and List Operations

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Demonstrates how to search for anime with filters and list anime with pagination and genre filtering using the Kodik library. It also shows how to retrieve episode and translation information for a specific anime.

```python
search = KodikSearch()
query = search.title("Overlord").limit(5).anime_kind(KodikSearch.AnimeKind.tv).with_material_data()
response = query.execute()

print(f"Found {response.total} results")
for result in response.results:
    print(f"{result.title} - {result.year}")
    print(f"  Shikimori ID: {result.shikimori_id}")
    print(f"  Translation: {result.translation.title}")

listing = KodikList()
query = listing.anime_kind(KodikList.AnimeKind.tv).anime_status("ongoing").limit(10)
data = query.execute()

next_data = query.next_page()
prev_data = query.prev_page()

query = KodikList().anime_genres([
    KodikSearch.AnimeGenres.fantasy,
    KodikSearch.AnimeGenres.military
]).limit(20)

result = KodikSearch().shikimori_id("20").execute()
episodes_info = result.results[0].get_episodes_and_translations()

# Output:
# [
#     {"episodes_count": 220, "title": "AniDUB", "translation_id": 609, "type": "voice"},
#     {"episodes_count": 220, "title": "Subtitles", "translation_id": 869, "type": "subtitles"}
# ]
```

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

### Handle AnimeParser Errors with Python Exceptions

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Demonstrates how to use custom exceptions provided by the AnimeParsers library to handle specific error conditions during anime searches and information retrieval. It covers common errors like invalid tokens, no results, service errors, rate limiting, and content restrictions.

```python
from anime_parsers_ru import KodikParser, ShikimoriParser
from anime_parsers_ru.errors import (
    TokenError,
    ServiceError,
    NoResults,
    TooManyRequests,
    ContentBlocked,
    AgeRestricted,
    UnexpectedBehavior,
    DecryptionFailure,
    ServiceIsOverloaded,
    QualityNotFound
)

parser = KodikParser(token="your_token")

try:
    results = parser.search("NonexistentAnime12345")
except TokenError as e:
    print(f"Invalid or missing token: {e}")
except NoResults as e:
    print(f"No results found: {e}")
except ServiceError as e:
    print(f"Server error: {e}")

shiki = ShikimoriParser()

try:
    info = shiki.anime_info("https://shikimori.one/animes/some-anime")
except TooManyRequests as e:
    print("Rate limited - wait before retrying")
except AgeRestricted as e:
    print("Content blocked by age restriction (requires auth)")
except ServiceIsOverloaded as e:
    print("Server overloaded (HTTP 520) - retry later")
except ContentBlocked as e:
    print(f"Content blocked in region: {e}")
```

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

### KodikSearch and KodikList API Classes (Python)

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Provides advanced interfaces for interacting with the Kodik API using chainable query builders. These classes facilitate complex search and list operations for anime data.

```python
from anime_parsers_ru import KodikSearch, KodikList
```

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

### ShikimoriParser - GraphQL Deep Search

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Performs advanced searches using Shikimori's GraphQL API with custom parameters and specifies the return fields.

```APIDOC
## POST /shikimori/deep_search

### Description
Performs advanced searches using Shikimori's GraphQL API with custom parameters and specifies the return fields.

### Method
POST

### Endpoint
/shikimori/deep_search

### Parameters
#### Request Body
- **title** (string) - Required - The title to search for.
- **search_parameters** (object) - Optional - Custom parameters for the search (e.g., limit, kind, status, rating, order, censored).
- **return_parameters** (array) - Optional - A list of fields to return in the search results (e.g., "id", "name", "poster { originalUrl }").

### Request Example
```python
# Example usage (not a direct API call)
results = parser.deep_search(
    title="Culinary Adventures",
    search_parameters={
        "limit": 5,
        "kind": "tv",
        "status": "released",
        "rating": "pg_13",
        "order": "ranked",
        "censored": False
    },
    return_parameters=[
        "id",
        "name",
        "russian",
        "score",
        "status",
        "episodes",
        "rating",
        "poster { originalUrl }",
        "genres { russian }",
        "studios { name }",
        "description"
    ]
)

for anime in results:
    print(f"{anime['russian']} ({anime['name']})")
    print(f"  Score: {anime['score']}")
    print(f"  Episodes: {anime['episodes']}")
    if anime.get('studios'):
        print(f"  Studio: {anime['studios'][0]['name']}")
```

### Response
#### Success Response (200)
- **results** (array) - A list of anime objects matching the search criteria, with fields specified in `return_parameters`.
```

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

### KodikParser: Search Anime by Title (Python)

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Searches the Kodik database for anime titles. Requires a Kodik API token. Returns a list of dictionaries containing anime metadata, including titles, years, types, and links. Supports filtering by status and limiting results.

```python
from anime_parsers_ru import KodikParser

# Initialize with your Kodik API token
parser = KodikParser(token="your_kodik_api_token")

# Search for anime by title
results = parser.search(
    title="Naruto",
    limit=10,
    include_material_data=True,
    anime_status="released",  # Options: "released", "ongoing", None
    strict=False,
    only_anime=True
)

# Output: List of dictionaries
# [
#     {
#         "title": "Naruto",
#         "title_orig": "Naruto",
#         "type": "anime-serial",
#         "year": 2002,
#         "screenshots": ["https://i.kodik.biz/screenshots\/..."],
#         "shikimori_id": "20",
#         "kinopoisk_id": "283290",
#         "imdb_id": "tt0409591",
#         "worldart_link": "http://www.world-art.ru/animation/...",
#         "material_data": {...},  # Additional metadata
#         "link": "//kodik.info/serial/6647/.../720p"
#     }
# ]

for anime in results:
    print(f"{anime['title']} ({anime['year']}) - {anime['type']}")
```

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

### KodikParser: Search by External ID (Python)

Source: https://context7.com/yanesytortik/animeparsers/llms.txt

Searches for anime using external IDs from Shikimori, Kinopoisk, or IMDb. Retrieves detailed information including series count and available translations. Requires a Kodik API token.

```python
from anime_parsers_ru import KodikParser

parser = KodikParser(token="your_kodik_api_token")

# Search by Shikimori ID
results = parser.search_by_id(
    id="20",           # Naruto's Shikimori ID
    id_type="shikimori",  # Options: "shikimori", "kinopoisk", "imdb"
    limit=50
)

# Get detailed info including translations and episode count
info = parser.get_info(id="20", id_type="shikimori")

# Output:
# {
#     "series_count": 220,
#     "translations": [
#         {"id": "609", "type": "Dubbing", "name": "AniDUB (220 ep.)"},
#         {"id": "610", "type": "Dubbing", "name": "AniLibria.TV (220 ep.)"},
#         {"id": "869", "type": "Subtitles", "name": "Subtitles (220 ep.)"}
#     ]
# }

print(f"Episodes: {info['series_count']}")
for trans in info['translations']:
    print(f"  {trans['name']} - {trans['type']}")
```
Tokens:
Raw