# Anime Release & Legal Streaming Discovery Intelligence (`obliging_persimmon_cki/anime-release-legal-streaming-discovery-intelligence`) Actor

Resolve anime titles into normalized metadata, schedules, source relations, and legal streaming discovery links with conservative matching.

- **URL**: https://apify.com/obliging\_persimmon\_cki/anime-release-legal-streaming-discovery-intelligence.md
- **Developed by:** [Dung Huynh](https://apify.com/obliging_persimmon_cki) (community)
- **Categories:** Other, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 normalized anime results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Anime Release & Legal Streaming Discovery Intelligence

Resolve anime titles into normalized metadata, release schedules, source/adaptation relations, provider-level streaming discovery, and optional raw legal-link evidence. Each dataset row represents one distinct, high-confidence anime entity.

This Actor is discovery intelligence for catalogs, research, and monitoring pipelines—not a generic AniList dump.

Store short description: resolve anime titles into normalized metadata, schedules, source relations, and legal streaming discovery links with conservative matching.

### What this Actor does

- Resolves English, Romaji, native, exact, short, and broad anime queries.
- Keeps TV series, seasons, movies, specials, OVAs, ONAs, and remakes separate when they are distinct entities.
- Normalizes identity, external IDs, release dates, airing state, studios, relations, and source provenance.
- Aggregates streaming evidence to one provider row while retaining raw links when requested.
- Uses AniList through a replaceable, operator-gated adapter and Jikan as a replaceable fallback.
- Keeps metadata usable when an optional source or streaming discovery step fails.

### Use cases

- Anime catalog enrichment
- Current-airing and upcoming-release tracking
- Scheduled release monitoring
- Legal streaming-link discovery
- Adaptation and source-material mapping
- Anime databases, apps, content, and research pipelines

### Quick start

```json
{
  "query": "Cowboy Bebop",
  "maxResults": 1,
  "includeSchedule": true,
  "includeStreamingLinks": true,
  "includeRelations": true,
  "includeAdult": false
}
```

The default is Store-safe: one result, schedule and streaming discovery enabled, relations enabled, and adult results disabled. See [`samples/input.default.json`](samples/input.default.json).

#### Input semantics

`query` accepts an English, Romaji, or native title and is required. `maxResults` is the maximum number of distinct high-confidence anime entities returned. It is not a request to fill the dataset with weak or ambiguous matches. Exact title queries commonly return one row; broad queries can return several. Duplicate AniList/MAL entities are removed.

`includeSchedule`, `includeStreamingLinks`, `includeRelations`, and `includeAdult` control optional output and source work. When `includeStreamingLinks` is `false`, both `streamingDiscovery` and `streamingProviders` are omitted. Source and commercial-policy configuration is operator-side, not consumer input.

### Main output

Each row follows this shape:

```json
{
  "recordType": "anime_release_legal_streaming_discovery",
  "query": "Cowboy Bebop",
  "entityMatch": { "confidence": 1, "level": "high", "ambiguity": false },
  "identity": {
    "canonicalTitle": "Cowboy Bebop",
    "format": "TV",
    "episodes": 26,
    "season": "SPRING",
    "seasonYear": 1998,
    "sourceMaterial": "ORIGINAL"
  },
  "externalIds": { "mal": 1, "anilist": 1 },
  "release": {
    "status": "FINISHED",
    "startDate": "1998-04-03",
    "endDate": "1999-04-24",
    "currentlyAiring": false,
    "nextEpisode": null,
    "nextAiringAt": null,
    "scheduleStatus": "unknown",
    "source": "anilist"
  },
  "studios": ["Sunrise"],
  "streamingProviders": [
    {
      "provider": "crunchyroll",
      "source": "anilist",
      "linkType": "episode_links",
      "linkCount": 26,
      "confidence": 0.45,
      "sampleUrl": "https://www.crunchyroll.com/watch/example"
    }
  ],
  "streamingDiscovery": [
    {
      "provider": "crunchyroll",
      "type": "legal_streaming_link",
      "url": "https://www.crunchyroll.com/watch/example",
      "source": "anilist",
      "confidence": 0.45,
      "evidence": ["streamingEpisodes"]
    }
  ],
  "relations": [],
  "dataQuality": {
    "entityMatch": { "score": 1, "level": "high" },
    "metadata": { "score": 0.9, "level": "high" },
    "schedule": { "score": 0.55, "level": "low" },
    "streamingDiscovery": { "score": 0.45, "level": "low" },
    "overall": { "score": 0.76, "level": "medium" },
    "status": "complete",
    "warnings": []
  },
  "sources": [{ "name": "anilist", "status": "success", "warnings": [], "errorCode": null }],
  "fetchedAt": "2026-08-08T00:00:00.000Z"
}
```

See the complete example in [`samples/output.default.json`](samples/output.default.json).

### Output fields

| Field | Meaning |
|---|---|
| `identity.canonicalTitle` | Canonical title selected for this distinct anime entity. |
| `identity.format` | Format such as TV, MOVIE, SPECIAL, OVA, or ONA. |
| `release.status` | Authoritative source release status. |
| `release.seasonYear` | Release season year when supplied by the source. |
| `identity.episodes` | Episode count when supplied by the source. |
| `release.currentlyAiring` | Source-backed airing indicator. |
| `release.nextEpisode` | Next episode number when schedule data provides it. |
| `release.nextAiringAt` | Next airing timestamp when schedule data provides it. |
| `streamingProviders` | One provider-level aggregate per normalized provider when streaming discovery is enabled. |
| `identity.sourceMaterial` | Source-material classification when supplied by the source. |
| `dataQuality.entityMatch` | Entity-match evidence score and level. |
| `dataQuality.overall` | Overall evidence-quality score and level. |
| `entityMatch` | Public match confidence and ambiguity status. |
| `identity` | Canonical titles, format, episodes, season/year, and source material. |
| `externalIds` | AniList and MAL identifiers when supplied. |
| `release` | Dates, status, airing state, and schedule fields. |
| `studios` | Normalized studio names when supplied. |
| `streamingDiscovery` | Deduplicated raw legal-link evidence when enabled. |
| `relations` | One-level normalized related-anime records. |
| `dataQuality` | Component evidence-quality scores, overall status, and warnings. |
| `sources` | Concise source outcome and warning records. |
| `query` | Original normalized search query. |
| `fetchedAt` | Observation timestamp. |

### Entity matching and release semantics

Matching is conservative. Exact title conflicts remain ambiguous, low-confidence candidates are skipped, and the Actor never selects a false entity merely to satisfy `maxResults`. Distinct seasons, films, specials, and related formats remain separate when they genuinely match.

`release.status` is the authoritative status field. `startDate`, `endDate`, `season`, and `seasonYear` are normalized source values. `currentlyAiring`, `nextEpisode`, and `nextAiringAt` are populated only from source schedule data; the Actor does not infer missing schedule values. `scheduleStatus` is `available`, `unknown`, or `not_requested`.

Relations are one level deep and deterministic. Common `relationType` values include `SOURCE`, `ADAPTATION`, `PREQUEL`, and `SEQUEL`; each relation contains `mediaType`, a title, and nullable AniList/MAL IDs. Relation trees are not recursively fetched.

### Streaming discovery semantics

When enabled, `streamingDiscovery` contains deduplicated raw legal-link evidence and `streamingProviders` contains one normalized aggregate per provider:

- `linkCount` counts valid unique links for that provider.
- `sampleUrl` is one representative link.
- `source` preserves provenance and `confidence` describes evidence quality.
- Provider links are discovery evidence only. They are not availability, entitlement, licensing, country, or playback claims.

The Actor does not implement regional availability, regional proxy logic, TMDB, JustWatch, Crunchyroll scraping, or piracy-link collection.

### Confidence and data quality

Scores represent evidence quality, not statistical probabilities. `entityMatch`, `metadata`, `schedule`, `streamingDiscovery`, and `overall` each expose a score and `low`/`medium`/`high` level. `dataQuality.status` is `complete`, `partial`, or `metadata_only`; warnings are concise and actionable. Source request counts, latency, and fallback diagnostics are kept in `RUN_SUMMARY`.

### API and scheduling

Use the Apify API or client libraries to start the Actor with the input above and read the default dataset:

```bash
apify call dhHckfKSDz9g7Dnkc \
  --input-file samples/input.default.json \
  --json
```

For recurring monitoring, schedule the Actor with `includeSchedule: true` and compare `release.nextEpisode`, `release.nextAiringAt`, and `fetchedAt` between runs. Keep `maxResults` small for exact titles and increase it only for broad discovery queries. Every successful normalized Dataset row is one billable `anime-result` event.

### Pricing

This Actor uses pay-per-event pricing at $0.010 per successfully produced normalized anime result. Examples are approximately $0.01 for one exact-title result, $0.03 for three broad-query results, up to $0.10 for ten results, and up to $0.20 for twenty results. Actual charges depend on the number of distinct high-confidence entities written to the Dataset; candidates, raw links, provider aggregates, source requests, and ambiguous or zero-result queries are not billable events.

The Actor is published on Apify Store. Pricing is pay-per-event, and users can set a maximum run charge.

### Source policy and limitations

AniList is enabled only through the replaceable adapter and an explicit operator policy gate. Use `ANILIST_COMMERCIAL_POLICY=under_threshold` only while the operator has confirmed monthly revenue remains below $150; use `licensed` after a commercial license is confirmed. The Actor cannot reliably know monthly revenue and does not automate enforcement. Do not mass-collect, hoard, or use AniList as backup storage.

Jikan is a fallback adapter and is not assumed reliable. Source failures can produce partial output or no result, while a usable source result remains non-fatal. Respect upstream terms, rate limits, attribution requirements, and freshness limits.

Streaming links are discovery evidence only. They do not prove availability, playback entitlement, or licensing status for a viewer. Jikan remains fallback-only and is not assumed reliable.

### Responsible use

Do not use discovered links to bypass access controls or geo restrictions. Validate freshness and source permissions before using results in paid or user-facing products.

# Actor input Schema

## `query` (type: `string`):

Search by an English, Romaji, or native anime title. Use a broad franchise term to discover several distinct anime entities.

## `maxResults` (type: `integer`):

Maximum number of distinct high-confidence anime entities returned. Low-confidence or ambiguous candidates are skipped, so fewer results may be returned.

## `includeSchedule` (type: `boolean`):

Include release status, airing state, and next-episode data when the source provides it. Missing schedule values remain null or unknown.

## `includeStreamingLinks` (type: `boolean`):

Include legal streaming links returned by the metadata source as discovery evidence, plus one aggregate per provider. Links are never regional availability claims.

## `includeRelations` (type: `boolean`):

Include one-level source, sequel, adaptation, and related-anime records when returned. Relation records are deduplicated and never recursively fetched.

## `includeAdult` (type: `boolean`):

Include adult metadata results when supported by the source.

## Actor input object example

```json
{
  "query": "Cowboy Bebop",
  "maxResults": 1,
  "includeSchedule": true,
  "includeStreamingLinks": true,
  "includeRelations": true,
  "includeAdult": false
}
```

# Actor output Schema

## `results` (type: `string`):

Normalized anime release, schedule, provenance, and legal streaming discovery records.

## `runSummary` (type: `string`):

Source outcomes, fallback warnings, result counts, and runtime.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "Cowboy Bebop",
    "maxResults": 1,
    "includeSchedule": true,
    "includeStreamingLinks": true,
    "includeRelations": true,
    "includeAdult": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("obliging_persimmon_cki/anime-release-legal-streaming-discovery-intelligence").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "Cowboy Bebop",
    "maxResults": 1,
    "includeSchedule": True,
    "includeStreamingLinks": True,
    "includeRelations": True,
    "includeAdult": False,
}

# Run the Actor and wait for it to finish
run = client.actor("obliging_persimmon_cki/anime-release-legal-streaming-discovery-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "Cowboy Bebop",
  "maxResults": 1,
  "includeSchedule": true,
  "includeStreamingLinks": true,
  "includeRelations": true,
  "includeAdult": false
}' |
apify call obliging_persimmon_cki/anime-release-legal-streaming-discovery-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,obliging_persimmon_cki/anime-release-legal-streaming-discovery-intelligence"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dhHckfKSDz9g7Dnkc/builds/ecRbF4vof5EcTpeO0/openapi.json