AnimeGarden: a mirror and open API for 動漫花園 BT releases

What AnimeGarden actually is, and who it is for

動漫花園 (dmhy) is a long-running Chinese-language BT release board. AnimeGarden is a third-party mirror of it, plus an aggregation layer over other anime release sources, run at animes.garden. The README calls it a mirror site and an anime BT resource aggregation site in the same sentence, and that dual role matters: it is not a tracker of its own, and it does not host torrent files in the sense a tracker does.

The audience is developers. The README's first bullet is an open API for developers, and the rest of the feature list follows that shape: an airing schedule page, advanced search syntax such as `葬送的芙莉莲 +简体内嵌 字幕组:桜都字幕组 类型:动画`, custom RSS feed URLs, saved searches, and integrations with AutoBangumi and AnimeSpace. If you want to watch anime, the website works, but nothing in the repository is designed around that use. If you want to query release metadata from a script, a bot, an agent or a home-server automation stack, that is the intended consumer.

The data flow: scrapers in, one query surface out

The repository is a pnpm and Turborepo monorepo with `apps/` and `packages/`. The top-level scripts name the moving parts directly: `build:server`, `build:web`, `build:worker` and `build:cli` filter the Turbo build to `@animegarden/server`, `@animegarden/web`, `@animegarden/worker` and `@animegarden/cli`. There is a `start:cron` script that runs `node apps/server/cli.mjs cron`, which tells you the ingestion side is a scheduled job rather than an always-on consumer.

One package is worth naming on its own. `packages/anipar` is described in the README as parsing structured metadata from a resource title. That is the piece that turns a raw release string into the fields the search UI and the API filter on, which is why the search syntax can ask for a fansub or a type at all. The storage side is not documented in the README; the root `package.json` carries `drizzle-kit` and `@types/better-sqlite3` as dev dependencies, and `wrangler` plus `@cloudflare/workers-types` are present too, so SQLite and Cloudflare Workers both appear in the toolchain. The README does not state which one serves production traffic, and I would not guess.

The public surface is the part that is well specified. `https://api.animes.garden/mcp` is an MCP endpoint, and the interactive Open API documentation lives at https://animes.garden/docs/api, with more request examples in `examples/api.http`.

Installing the client and running a first query

The fastest path is the npm client, which the README describes as a wrapper over the HTTP API requests. Install it with:

npm i @animegarden/client

Then fetch a page of resources. The README's own example calls `fetchResources` with no arguments for the first page of the mirror site, and with a filter object for a narrower set:

import { fetchResources } from '@animegarden/client'

// Fetch the first page of Anime Garden mirror site
const resources = await fetchResources()

// Fetch all the resources which match some filter conditions
const sakurato = await fetchResources({ count: -1, fansub: 'ANi' })

The README notes that `count: -1` means fetch everything matching the filter, so expect a long-running request rather than a single page. It also warns that your runtime needs a built-in Fetch; if it does not have one, install `undici` or `ofetch` as a polyfill. The full set of `FilterOptions` fields is not listed in the README, which points instead at `packages/client/src/types.ts` in the repository.

If you would rather not add a dependency, the API takes plain HTTP. The README gives this exact call:

curl "https://api.animes.garden/resources?page=1&pageSize=10"

On the resource list pages of the site itself, the README says you can copy generated cURL, JavaScript and Python request code for the current search, which is the quickest way to learn the parameter names for a filter you built in the UI.

Where AnimeGarden stops being the right tool

The mirror is a dependency, not an independent source. If 動漫花園 is unreachable or changes its markup, the ingested data is affected upstream of anything AnimeGarden does. The README does not document a fallback, a staleness indicator or a backfill procedure, and the cron entry point is the only ingestion trigger named in the repository. Anyone treating the API as a durable archive should check how far back results go before relying on it.

Second, the client is JavaScript and TypeScript. There is no first-party client for Python, Go or Rust in the repository; `examples/fetch.py` exists, but the README presents it as an example rather than a supported library, and the documented npm package is `@animegarden/client`. If your stack is not JS, you are writing your own HTTP layer against the Open API.

Third, the runtime floor is high. The root `package.json` sets `"node": ">=v24.0.0"` and pins `[email protected]`. Self-hosting means matching that, and the README does not describe deployment steps for the server or worker apps; it defers local setup to CONTRIBUTING.md. There is a `docker-compose.dev.yml` at the top level, but the README does not present it as a production recipe.

How it differs from running your own RSS reader over dmhy

The obvious alternative is subscribing to 動漫花園's own RSS directly, or to one of the other sources the README credits: 蜜柑计划, 萌番组, Bangumi 番组计划 and bangumi-data. Those give you a feed of new releases and nothing more. AnimeGarden's difference is the parsed metadata layer. Because `anipar` extracts structure from titles, the API and the feed builder can filter on fansub, on release type, on include and exclude keywords, and the site can offer saved searches that regenerate as an RSS URL. A raw dmhy feed cannot answer a question like "only 桜都字幕组 releases of this show with 简体内嵌 in the title" without you writing that parser yourself.

The cost of that convenience is the extra hop. You are trusting a third party's parser to classify releases correctly, and you are trusting its ingestion schedule to be current. If your tolerance for both is low, parsing dmhy yourself is more work but removes the dependency. AnimeSpace and AutoBangumi sit on the other side of this: they are consumers that the README says AnimeGarden integrates with, so if you already run one of those, the integration is the reason to care about this project rather than the API in isolation.

Licence, maintenance and what an upgrade costs you

The repository is AGPL-3.0, copyright 2023 XLor. That is a network copyleft licence: if you modify the code and let users interact with it over a network, the licence's obligations attach to that deployment. Running the public API as a client does not trigger anything, but forking the server and hosting your own instance is a decision to read the licence text carefully, and I am not going to tell you what it permits.

The last push to the default branch was on 2026-09-10, and the repository is not archived. The most recent tagged release listed is v0.5.4 on 2026-05-04, preceded by v0.5.3 on 2026-03-26 and v0.5.2 on 2025-05-26. The gap between v0.5.2 and v0.5.3 is roughly ten months, so release cadence has not been steady. The root `package.json` version is 0.5.4, matching the latest tag, and the release script uses `bumpp` across `package.json`, `packages/*/package.json` and `apps/*/package.json`, so a version bump touches every workspace at once. Upgrading a self-hosted instance means moving the whole monorepo, not one package.

For consumers rather than self-hosters, the upgrade surface is smaller: pin `@animegarden/client` and read the changelog between tags. The README does not describe a deprecation policy for API fields, so treat the Open API documentation as the current contract and re-check it after a version bump.

Editorial conclusion

Adopt AnimeGarden if you are building tooling that needs a queryable index of anime BT releases and you accept the AGPL-3.0 obligations that come with the code. Do not adopt it as a tracker or a downloader; it indexes release metadata, and the actual torrents live at the original 動漫花園 and its peers. Before you commit, open https://animes.garden/docs/api and confirm that the filter fields you need (fansub, type, include, keywords) are present in the live schema, because the README only points at the type definitions rather than listing them.

Frequently asked questions

Official sources

1. License: AGPL-3.0
2. Project website
3. README
4. Releases
5. yjl9903/AnimeGarden on GitHub