# JSR

> Look up JavaScript and TypeScript packages on JSR, the open-source registry from the Deno team. Search packages by name or scope and the runtimes they work on; read a package with its install commands, its score, its versions, one version's licence, exports and provenance, its dependencies and full dependency tree, the packages that depend on it, its downloads, its files and the text of any one of them, and the symbols its documentation lists; read a scope, its packages and members, and a user; and list new, updated and featured packages and the registry's totals. Triggers start a workflow when a package publishes a new version or a scope publishes a new package. Every action reads public data and changes nothing. No account or API key required.

App · 18 actions. Web page: https://docs.lodol.com/docs/integrations/jsr

## Actions

### Get a package

Read a package: its description, latest version and when it was published, any newer pre-release, how many versions it has, its score, the runtimes it works on, how many packages it depends on and how many depend on it, its GitHub repository, and the commands that install it in Deno or Node.js.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.

**Outputs**

- `compatible_runtimes` (list): Runtimes the package is marked as working on: deno, node, bun, workerd (Cloudflare Workers) or browser
- `created_at` (text): When the package was created on JSR, in ISO 8601 UTC
- `deno_add_command` (text): The command that adds it to a Deno project
- `dependency_count` (number): How many packages its latest version depends on
- `dependent_count` (number): How many packages on JSR depend on it
- `description` (text): The package's own one-line description
- `docs_url` (text): The package's API documentation on jsr.io
- `featured_at` (text): When JSR featured it, in ISO 8601 UTC; empty when never
- `first_published_at` (text): When its first version was published, in ISO 8601 UTC
- `github_repository` (text): The linked GitHub repository as owner/name; empty when none
- `github_url` (text): The linked GitHub repository's address; empty when none
- `import_specifier` (text): How code imports the latest version, such as jsr:@std/fs@^1.0.24
- `incompatible_runtimes` (list): Runtimes the package is marked as not working on; a runtime in neither list is unknown
- `is_archived` (true/false): True when its owners have archived it
- `is_featured` (true/false): True when JSR features it on its home page
- `latest_prerelease` (text): A pre-release published after the latest stable version, such as 2.0.0-rc.1; empty when there is none
- `latest_published_at` (text): When the latest stable version was published, in ISO 8601 UTC
- `latest_version` (text): The latest stable version; empty when it has no published version
- `name` (text): Its name within the scope
- `npm_package` (text): Its name in JSR's npm compatibility layer, such as @jsr/std__fs
- `npx_add_command` (text): The command that adds it to a Node.js project through JSR's npm compatibility layer
- `package` (text): The package's full name, such as @std/fs
- `readme_source` (text): Where its overview comes from: readme for a README file, jsdoc for the module documentation
- `scope` (text): The scope it is published under
- `score` (number): JSR's score out of 100; 0 when it has no published version
- `symbol_count` (number): How many symbols its latest version documents; 0 when JSR has not counted them
- `updated_at` (text): When its details on JSR last changed, in ISO 8601 UTC
- `url` (text): The package's page on jsr.io
- `version_count` (number): How many versions it has published
- `yanked_count` (number): How many of those versions are yanked

**Example output**

```json
{
  "compatible_runtimes": [
    "deno"
  ],
  "created_at": "2023-12-22T03:19:20Z",
  "deno_add_command": "deno add jsr:@std/fs",
  "dependency_count": 2,
  "dependent_count": 955,
  "description": "Helpers for working with the file system",
  "docs_url": "https://jsr.io/@std/fs/doc",
  "featured_at": "",
  "first_published_at": "2023-12-22T11:26:46Z",
  "github_repository": "denoland/std",
  "github_url": "https://github.com/denoland/std",
  "import_specifier": "jsr:@std/fs@^1.0.24",
  "incompatible_runtimes": [
    "node",
    "bun",
    "workerd",
    "browser"
  ],
  "is_archived": false,
  "is_featured": false,
  "latest_prerelease": "",
  "latest_published_at": "2026-05-26T09:57:22Z",
  "latest_version": "1.0.24",
  "name": "fs",
  "npm_package": "@jsr/std__fs",
  "npx_add_command": "npx jsr add @std/fs",
  "package": "@std/fs",
  "readme_source": "jsdoc",
  "scope": "std",
  "score": 94,
  "symbol_count": 0,
  "updated_at": "2024-03-13T02:23:41Z",
  "url": "https://jsr.io/@std/fs",
  "version_count": 69,
  "yanked_count": 2
}
```

### Get a package version

Read one version of a package: when it was published, whether it is the latest, a pre-release or yanked, its licence, the entrypoints it exports, how many files it holds and their size, and its provenance in the public Sigstore log.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Version (`version`, text, required): The version to read. Pick one from the list, or type a version number or latest for the newest stable release.

**Outputs**

- `exports` (list): The entrypoints it exports and the files behind them
- `file_count` (number): How many files it holds
- `has_provenance` (true/false): True when it was published with a provenance attestation
- `import_specifier` (text): How code imports exactly this version, such as jsr:@std/fs@1.0.24
- `is_latest` (true/false): True when it is the latest stable version
- `is_prerelease` (true/false): True for a pre-release such as 1.0.0-rc.1
- `is_yanked` (true/false): True when it is yanked, so new installs skip it
- `license` (text): The licence it declares, such as MIT; empty when it declares none
- `newer_versions_count` (number): How many versions were published after it
- `package` (text): The package's full name
- `provenance_url` (text): The attestation in the public Sigstore transparency log; empty when there is none
- `published_at` (text): When it was published, in ISO 8601 UTC
- `total_size_bytes` (number): The size of all its files together, in bytes
- `url` (text): This version's page on jsr.io
- `uses_npm` (true/false): True when it imports packages from npm
- `version` (text): The version number

**Example output**

```json
{
  "exports": [
    {
      "entrypoint": ".",
      "file": "./mod.ts"
    },
    {
      "entrypoint": "./copy",
      "file": "./copy.ts"
    },
    {
      "entrypoint": "./empty-dir",
      "file": "./empty_dir.ts"
    }
  ],
  "file_count": 91,
  "has_provenance": true,
  "import_specifier": "jsr:@std/fs@1.0.24",
  "is_latest": true,
  "is_prerelease": false,
  "is_yanked": false,
  "license": "MIT",
  "newer_versions_count": 0,
  "package": "@std/fs",
  "provenance_url": "https://search.sigstore.dev/?logIndex=1633013181",
  "published_at": "2026-05-26T09:57:22Z",
  "total_size_bytes": 424813,
  "url": "https://jsr.io/@std/fs@1.0.24",
  "uses_npm": false,
  "version": "1.0.24"
}
```

### Get a package's downloads

Read how often a package was downloaded over the last 90 days, through JSR itself and through its npm compatibility layer, with totals for the last 7 and 30 days, downloads of its most recent versions and, if you ask, a count for each day.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Include each day (`include_daily`, true/false): Also return the downloads of each of the 90 days. Default: `false`.

**Outputs**

- `days` (list): Downloads day by day, oldest first; empty unless asked for
- `first_day` (text): The first day counted, as YYYY-MM-DD
- `jsr_total` (number): Of those, downloads through JSR itself
- `last_30_days` (number): Downloads over the last 30 full days
- `last_7_days` (number): Downloads over the last 7 full days
- `last_day` (text): The last day counted, as YYYY-MM-DD; usually today
- `npm_total` (number): Of those, downloads through the npm compatibility layer
- `package` (text): The package that was read
- `total` (number): Downloads over the whole period, today so far included
- `versions` (list): Downloads of its most recent versions over the period

**Example output**

```json
{
  "days": [
    {
      "date": "2026-10-20",
      "jsr": 22409,
      "npm": 3353,
      "total": 25762
    },
    {
      "date": "2026-10-21",
      "jsr": 71255,
      "npm": 5531,
      "total": 76786
    },
    {
      "date": "2026-10-22",
      "jsr": 10542,
      "npm": 865,
      "total": 11407
    }
  ],
  "first_day": "2026-07-25",
  "jsr_total": 1216156,
  "last_30_days": 621964,
  "last_7_days": 199322,
  "last_day": "2026-10-22",
  "npm_total": 122232,
  "package": "@std/fs",
  "total": 1338388,
  "versions": [
    {
      "downloads": 743695,
      "version": "1.0.24"
    },
    {
      "downloads": 157065,
      "version": "1.0.23"
    }
  ]
}
```

### Get a package's score

Read JSR's score for a package and how it was earned, check by check: a README with examples, documented entrypoints and symbols, no slow types, provenance, a description, and the runtimes it is marked as working on.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.

**Outputs**

- `checks` (list): Each part of the score
- `documented_symbols_percent` (number): The share of exported symbols that have documentation, out of 100
- `entrypoints_without_docs` (list): Entrypoints missing module documentation
- `max_points` (number): The most points a package can earn
- `package` (text): The package that was read
- `points` (number): Points earned, out of max_points
- `score_percent` (number): JSR's score out of 100, as jsr.io shows it
- `url` (text): The package's score page on jsr.io

**Example output**

```json
{
  "checks": [
    {
      "id": "has_readme",
      "label": "Has a README or module documentation",
      "max_points": 2,
      "passed": true,
      "points": 2
    },
    {
      "id": "all_entrypoints_docs",
      "label": "Every entrypoint has module documentation",
      "max_points": 1,
      "passed": false,
      "points": 0
    },
    {
      "id": "no_slow_types",
      "label": "Has no slow types, so its types load fast",
      "max_points": 5,
      "passed": true,
      "points": 5
    }
  ],
  "documented_symbols_percent": 98.3,
  "entrypoints_without_docs": [],
  "max_points": 17,
  "package": "@std/fs",
  "points": 16,
  "score_percent": 94,
  "url": "https://jsr.io/@std/fs/score"
}
```

### Get a scope

Read a scope, the namespace packages are published under such as @std: its description, how many packages it holds and how many of them are published, how many members it has, and when it was created.

**Inputs**

- Scope (`scope`, text, required): The scope: the part of a package's name between @ and /, such as std in @std/fs. A jsr.io address works too.

**Outputs**

- `created_at` (text): When the scope was created, in ISO 8601 UTC
- `description` (text): How the scope describes itself
- `member_count` (number): How many people are members
- `package_count` (number): How many packages it holds
- `published_package_count` (number): How many of them have at least one published version
- `scope` (text): The scope's name, such as std
- `updated_at` (text): When it last changed, in ISO 8601 UTC
- `url` (text): The scope's page on jsr.io

**Example output**

```json
{
  "created_at": "2023-12-22T03:14:57Z",
  "description": "This is the Deno standard library. Read more about it https://docs.deno.com/runtime/fundamentals/standard_library/",
  "member_count": 3,
  "package_count": 43,
  "published_package_count": 43,
  "scope": "std",
  "updated_at": "2026-10-07T21:10:55Z",
  "url": "https://jsr.io/@std"
}
```

### Get a user

Read a JSR user's profile, the scopes they are a member of and the packages they published to recently. 'List a scope's members' and 'List a package's versions' give user ids.

**Inputs**

- User id (`user`, text, required): The user's JSR id, or their profile address on jsr.io.

**Outputs**

- `avatar_url` (text): The user's picture
- `created_at` (text): When they joined JSR, in ISO 8601 UTC
- `github_id` (number): The user's numeric GitHub account id; 0 when none
- `name` (text): The user's name
- `recent_package_count` (number): How many recent packages are listed
- `recent_packages` (list): Packages the user published to recently
- `scope_count` (number): How many scopes they are a member of
- `scopes` (list): The scopes the user is a member of
- `url` (text): The user's profile on jsr.io
- `user_id` (text): The user's JSR id

**Example output**

```json
{
  "avatar_url": "https://avatars.githubusercontent.com/u/80?v=4",
  "created_at": "2023-12-15T08:10:44Z",
  "github_id": 80,
  "name": "Ryan Dahl",
  "recent_package_count": 1,
  "recent_packages": [
    {
      "compatible_runtimes": [
        "deno"
      ],
      "created_at": "2025-05-06T04:22:45Z",
      "description": "",
      "github_repository": "",
      "is_featured": false,
      "latest_version": "0.4.2",
      "name": "cells",
      "package": "@ry/cells",
      "scope": "ry",
      "score": 58,
      "url": "https://jsr.io/@ry/cells",
      "version_count": 7
    }
  ],
  "scope_count": 2,
  "scopes": [
    {
      "description": "",
      "scope": "denoland",
      "url": "https://jsr.io/@denoland"
    },
    {
      "description": "This is the Deno standard library. Read more about it https://docs.deno.com/runtime/fundamentals/standard_library/",
      "scope": "std",
      "url": "https://jsr.io/@std"
    }
  ],
  "url": "https://jsr.io/user/0fcb759b-1efc-47e4-b9f6-6ae0baa90c3a",
  "user_id": "0fcb759b-1efc-47e4-b9f6-6ae0baa90c3a"
}
```

### Get a version's dependency tree

Work out everything one version of a package loads: every JSR package it pulls in, directly or not, at the version that resolves, with how many files and bytes each adds, and the total. npm packages it uses are not included.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Version (`version`, text, required): The version to read. Pick one from the list, or type a version number or latest for the newest stable release.

**Outputs**

- `own_module_count` (number): How many of the package's own files are loaded
- `own_size_bytes` (number): The size of those files, in bytes
- `package` (text): The package that was read
- `package_count` (number): How many JSR packages it pulls in
- `packages` (list): Every JSR package it pulls in, directly or not, largest first
- `total_module_count` (number): How many files are loaded altogether
- `total_size_bytes` (number): The size of every file loaded, its own and its dependencies', in bytes
- `version` (text): The version whose tree this is

**Example output**

```json
{
  "own_module_count": 50,
  "own_size_bytes": 181322,
  "package": "@std/fs",
  "package_count": 2,
  "packages": [
    {
      "module_count": 45,
      "package": "@std/path",
      "size_bytes": 77214,
      "url": "https://jsr.io/@std/path@1.1.6",
      "version": "1.1.6"
    },
    {
      "module_count": 2,
      "package": "@std/internal",
      "size_bytes": 767,
      "url": "https://jsr.io/@std/internal@1.0.14",
      "version": "1.0.14"
    }
  ],
  "total_module_count": 97,
  "total_size_bytes": 259303,
  "version": "1.0.19"
}
```

### Get registry statistics

Read how many packages, versions and users JSR has, and how many of each were added in the last day, 7 days and 30 days.

**Inputs**: None.

**Outputs**

- `package_count` (number): Packages on JSR
- `packages_last_30_days` (number): Packages created in the last 30 days
- `packages_last_7_days` (number): Packages created in the last 7 days
- `packages_last_day` (number): Packages created in the last day
- `user_count` (number): Users signed up to JSR
- `users_last_30_days` (number): Users who joined in the last 30 days
- `users_last_7_days` (number): Users who joined in the last 7 days
- `users_last_day` (number): Users who joined in the last day
- `version_count` (number): Versions published on JSR
- `versions_last_30_days` (number): Versions published in the last 30 days
- `versions_last_7_days` (number): Versions published in the last 7 days
- `versions_last_day` (number): Versions published in the last day

**Example output**

```json
{
  "package_count": 18224,
  "packages_last_30_days": 2365,
  "packages_last_7_days": 751,
  "packages_last_day": 182,
  "user_count": 21497,
  "users_last_30_days": 210,
  "users_last_7_days": 43,
  "users_last_day": 1,
  "version_count": 249065,
  "versions_last_30_days": 19634,
  "versions_last_7_days": 3085,
  "versions_last_day": 402
}
```

### List a package's dependents

List the packages on JSR that depend on a package, with the versions of each that do, and how many dependents it has altogether.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- How many to return (`limit`, number): How many dependents to return, up to 500. Defaults to 20; the result says how many there are altogether. From 1 to 500. Default: `20`.

**Outputs**

- `count` (number): How many dependents are in this result
- `dependents` (list): Packages that depend on it, in alphabetical order
- `package` (text): The package that was read
- `total_count` (number): How many packages depend on it altogether

**Example output**

```json
{
  "count": 2,
  "dependents": [
    {
      "name": "build",
      "package": "@24wings/build",
      "scope": "24wings",
      "url": "https://jsr.io/@24wings/build",
      "version_count": 1,
      "versions": [
        "0.0.8"
      ]
    },
    {
      "name": "aether",
      "package": "@404/aether",
      "scope": "404",
      "url": "https://jsr.io/@404/aether",
      "version_count": 22,
      "versions": [
        "0.5.0",
        "0.6.0"
      ]
    }
  ],
  "package": "@std/fs",
  "total_count": 967
}
```

### List a package's symbols

List the functions, classes, interfaces, types and other symbols the latest version of a package exports, from its documentation on JSR, each with its description and a link to its page. Narrow it by kind, name or entrypoint.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Kinds (`kinds`, list): Only symbols of these kinds. Leave empty for every kind except the methods and properties of classes and interfaces. One or more of: `Function` (Functions), `Class` (Classes), `Interface` (Interfaces), `TypeAlias` (Type aliases), `Variable` (Variables and constants), `Enum` (Enums), `Namespace` (Namespaces), `Method` (Methods of classes and interfaces), `Property` (Properties of classes and interfaces).
- Name contains (`name_contains`, text): Only symbols whose name contains this text. Leave empty for all.
- Entrypoint (`entrypoint`, text): Only symbols exported from this entrypoint, such as copy for @std/fs/copy, or . for the package itself. Leave empty for every entrypoint.
- Include deprecated symbols (`include_deprecated`, true/false): Include symbols marked as deprecated. Default: `true`.
- How many to return (`limit`, number): How many symbols to return, up to 500. Defaults to 50; the result says how many matched altogether. From 1 to 500. Default: `50`.

**Outputs**

- `count` (number): How many symbols are in this result
- `matched_count` (number): How many matched before the limit trimmed the list
- `package` (text): The package that was read
- `symbols` (list): The matching symbols
- `total_count` (number): How many symbols the documentation holds altogether
- `version` (text): The version documented: always the latest

**Example output**

```json
{
  "count": 2,
  "matched_count": 16,
  "package": "@std/fs",
  "symbols": [
    {
      "description": "Asynchronously ensures that the directory exists, like mkdir -p. If the directory already exists, this function does nothing.",
      "entrypoint": ".",
      "is_deprecated": false,
      "kind": "Function",
      "name": "ensureDir",
      "url": "https://jsr.io/@std/fs/doc/~/ensureDir"
    },
    {
      "description": "Synchronously ensures that the directory exists, like mkdir -p.",
      "entrypoint": ".",
      "is_deprecated": false,
      "kind": "Function",
      "name": "ensureDirSync",
      "url": "https://jsr.io/@std/fs/doc/~/ensureDirSync"
    }
  ],
  "total_count": 229,
  "version": "1.0.24"
}
```

### List a package's versions

List the versions a package has published, newest first or by version number, with when each came out, who published it, and whether it is a pre-release, yanked or published with provenance. Narrow it to stable releases or pre-releases, or to a range of publication dates.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Versions (`release_kind`, text): Which versions to list: every version, stable releases only, or pre-releases such as 1.0.0-rc.1 only. Leave empty for every version.
- Include yanked versions (`include_yanked`, true/false): Include versions their owners have yanked, which new installs skip. Default: `true`.
- Published on or after (`published_after`, date): Only versions published on this day or later (UTC). Leave empty for no limit.
- Published on or before (`published_before`, date): Only versions published on this day or earlier (UTC). Leave empty for no limit.
- Order (`order`, text): Which version comes first. One of: `published` (Most recently published first), `version` (Highest version number first). Default: `published`.
- How many to return (`limit`, number): How many versions to return, up to 500. Defaults to 25; the result says how many matched altogether. From 1 to 500. Default: `25`.

**Outputs**

- `count` (number): How many versions are in this result
- `latest_version` (text): The latest stable version
- `matched_count` (number): How many matched before the limit trimmed the list
- `order` (text): published for most recently published first, version for highest version first
- `package` (text): The package that was read
- `total_count` (number): How many versions the package has altogether
- `versions` (list): The matching versions, in the order asked for

**Example output**

```json
{
  "count": 2,
  "latest_version": "1.0.24",
  "matched_count": 6,
  "order": "published",
  "package": "@std/fs",
  "total_count": 69,
  "versions": [
    {
      "has_provenance": true,
      "is_prerelease": true,
      "is_yanked": false,
      "published_at": "2024-07-19T11:26:11Z",
      "published_by": "Yoshiya Hinosawa",
      "published_by_id": "dad74aa9-73f3-417a-9137-b100692f3510",
      "url": "https://jsr.io/@std/fs@1.0.0-rc.6",
      "uses_npm": false,
      "version": "1.0.0-rc.6"
    },
    {
      "has_provenance": true,
      "is_prerelease": true,
      "is_yanked": false,
      "published_at": "2024-07-12T10:50:41Z",
      "published_by": "Yoshiya Hinosawa",
      "published_by_id": "dad74aa9-73f3-417a-9137-b100692f3510",
      "url": "https://jsr.io/@std/fs@1.0.0-rc.5",
      "uses_npm": false,
      "version": "1.0.0-rc.5"
    }
  ]
}
```

### List a scope's members

List the people who can publish to a scope, admins first, with their JSR user id, GitHub account id and when they joined.

**Inputs**

- Scope (`scope`, text, required): The scope: the part of a package's name between @ and /, such as std in @std/fs. A jsr.io address works too.

**Outputs**

- `admin_count` (number): How many of them are admins
- `count` (number): How many members it has
- `members` (list): The scope's members, admins first
- `scope` (text): The scope that was read

**Example output**

```json
{
  "admin_count": 1,
  "count": 2,
  "members": [
    {
      "avatar_url": "https://avatars.githubusercontent.com/u/33910674?v=4",
      "github_id": 33910674,
      "is_admin": true,
      "joined_at": "2026-10-06T01:33:17Z",
      "name": "denobot",
      "url": "https://jsr.io/user/87861f53-2295-439a-97ca-ba078222c8df",
      "user_id": "87861f53-2295-439a-97ca-ba078222c8df"
    },
    {
      "avatar_url": "https://avatars.githubusercontent.com/u/80?v=4",
      "github_id": 80,
      "is_admin": false,
      "joined_at": "2023-12-22T03:14:57Z",
      "name": "Ryan Dahl",
      "url": "https://jsr.io/user/0fcb759b-1efc-47e4-b9f6-6ae0baa90c3a",
      "user_id": "0fcb759b-1efc-47e4-b9f6-6ae0baa90c3a"
    }
  ],
  "scope": "std"
}
```

### List a scope's packages

List the packages in a scope, by name, score, newest first or most versions, each with its latest version, description, score and the runtimes it works on. Narrow it to packages that work on the runtimes you choose.

**Inputs**

- Scope (`scope`, text, required): The scope: the part of a package's name between @ and /, such as std in @std/fs. A jsr.io address works too.
- Works on (`runtimes`, list): Only packages marked as working on every runtime chosen. Leave empty for any. One or more of: `deno`, `node` (Node.js), `bun`, `workerd` (Cloudflare Workers), `browser` (Browsers).
- Include packages with nothing published (`include_unpublished`, true/false): Include packages that exist but have never published a version, which cannot be installed. Default: `false`.
- Sort by (`sort`, text): Which packages come first. One of: `name`, `score` (Highest score first), `newest` (Newest packages first), `versions` (Most versions first). Default: `name`.
- How many to return (`limit`, number): How many packages to return, up to 500. Defaults to 50; the result says how many matched altogether. From 1 to 500. Default: `50`.

**Outputs**

- `count` (number): How many packages are in this result
- `matched_count` (number): How many matched before the limit trimmed the list
- `packages` (list): The matching packages, in the order asked for
- `scope` (text): The scope that was read
- `sort` (text): The order the packages are in: name, score, newest or versions
- `total_count` (number): How many packages the scope holds

**Example output**

```json
{
  "count": 2,
  "matched_count": 29,
  "packages": [
    {
      "compatible_runtimes": [
        "deno",
        "node",
        "bun",
        "workerd",
        "browser"
      ],
      "created_at": "2023-12-22T10:58:46Z",
      "description": "Common assertion functions, especially useful for testing",
      "github_repository": "denoland/std",
      "is_featured": true,
      "latest_version": "1.0.19",
      "name": "assert",
      "package": "@std/assert",
      "scope": "std",
      "score": 100,
      "url": "https://jsr.io/@std/assert",
      "version_count": 62
    },
    {
      "compatible_runtimes": [
        "deno",
        "node",
        "bun",
        "workerd",
        "browser"
      ],
      "created_at": "2023-12-22T03:19:08Z",
      "description": "Utilities for asynchronous operations, like delays, debouncing, or pooling",
      "github_repository": "denoland/std",
      "is_featured": false,
      "latest_version": "1.5.1",
      "name": "async",
      "package": "@std/async",
      "scope": "std",
      "score": 100,
      "url": "https://jsr.io/@std/async",
      "version_count": 64
    }
  ],
  "scope": "std",
  "sort": "score",
  "total_count": 43
}
```

### List a version's dependencies

List the JSR and npm packages one version of a package imports, with the version range it asks for and the parts of each it uses.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Version (`version`, text, required): The version to read. Pick one from the list, or type a version number or latest for the newest stable release.

**Outputs**

- `count` (number): How many packages it depends on
- `dependencies` (list): What this version imports from other packages
- `jsr_count` (number): How many of them are JSR packages
- `npm_count` (number): How many of them are npm packages
- `package` (text): The package that was read
- `version` (text): The version whose dependencies these are

**Example output**

```json
{
  "count": 2,
  "dependencies": [
    {
      "constraint": "^1.0.9",
      "entrypoints": [
        "os"
      ],
      "kind": "jsr",
      "package": "@std/internal",
      "url": "https://jsr.io/@std/internal"
    },
    {
      "constraint": "^1.1.1",
      "entrypoints": [
        "basename",
        "dirname",
        "join",
        "normalize",
        "resolve"
      ],
      "kind": "jsr",
      "package": "@std/path",
      "url": "https://jsr.io/@std/path"
    }
  ],
  "jsr_count": 2,
  "npm_count": 0,
  "package": "@std/fs",
  "version": "1.0.19"
}
```

### List a version's files

List the files one version of a package publishes, with each file's size and checksum and the version's total size, optionally only paths containing some text.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Version (`version`, text, required): The version to read. Pick one from the list, or type a version number or latest for the newest stable release.
- Path contains (`path_contains`, text): Only files whose path contains this text. Leave empty for all.
- How many to return (`limit`, number): How many files to return, up to 1000. Defaults to 100; the result says how many matched altogether. From 1 to 1000. Default: `100`.

**Outputs**

- `count` (number): How many files are in this result
- `files` (list): The matching files, by path
- `matched_count` (number): How many matched before the limit trimmed the list
- `package` (text): The package that was read
- `total_count` (number): How many files the version holds
- `total_size_bytes` (number): The size of all its files together, in bytes
- `version` (text): The version whose files these are

**Example output**

```json
{
  "count": 2,
  "files": [
    {
      "checksum": "sha256-90020857b22c542d6dbcd1d778b4fcdba59ddd041b52b20c40f5fe620b06ee9d",
      "path": "/copy.ts",
      "size_bytes": 11381
    },
    {
      "checksum": "sha256-ef8f2ec973319380188eacb566b6a3ddeb3ebfeef197ed7a189232ceef76000f",
      "path": "/copy_test.ts",
      "size_bytes": 16072
    }
  ],
  "matched_count": 8,
  "package": "@std/fs",
  "total_count": 117,
  "total_size_bytes": 424797,
  "version": "1.0.19"
}
```

### List new, updated and featured packages

List what JSR's home page shows: the ten packages created most recently, the ten versions published most recently, and the packages JSR features.

**Inputs**

- Lists (`section`, text): Which list to read, or all three. One of: `all` (All three lists), `newest` (Newest packages), `updated` (Latest releases), `featured` (Featured packages). Default: `all`.

**Outputs**

- `featured` (list): The packages JSR features on its home page; empty unless asked for
- `newest` (list): The packages created most recently, newest first; empty unless asked for
- `section` (text): Which lists were asked for: all, newest, updated or featured
- `updated` (list): The versions published most recently, newest first; empty unless asked for

**Example output**

```json
{
  "featured": [
    {
      "description": "A type-safe TypeScript SQL query builder",
      "package": "@kysely/kysely",
      "url": "https://jsr.io/@kysely/kysely"
    },
    {
      "description": "Web framework built on Web Standards",
      "package": "@hono/hono",
      "url": "https://jsr.io/@hono/hono"
    }
  ],
  "newest": [
    {
      "description": "Package to compute index numbers",
      "package": "@paluigi/jsindexnum",
      "url": "https://jsr.io/@paluigi/jsindexnum"
    },
    {
      "description": "",
      "package": "@wazoo/reasoner",
      "url": "https://jsr.io/@wazoo/reasoner"
    }
  ],
  "section": "all",
  "updated": [
    {
      "description": "i18next internationalization framework",
      "package": "@i18next/i18next",
      "url": "https://jsr.io/@i18next/i18next@26.5.5",
      "version": "26.5.5"
    },
    {
      "description": "",
      "package": "@vizejs/vize",
      "url": "https://jsr.io/@vizejs/vize@0.534.0",
      "version": "0.534.0"
    }
  ]
}
```

### Read a file from a package

Read the text of one file a version of a package publishes, such as its README, deno.json, licence or a source file. Files up to 1 MB can be read, and the first 100,000 characters are returned.

**Inputs**

- Package (`package`, text, required): The package, as @scope/name. Pick a featured or standard library package from the list, or type any; a jsr.io address works too.
- Version (`version`, text, required): The version to read. Pick one from the list, or type a version number or latest for the newest stable release.
- File (`path`, text, required): The file to read. Pick one from the list, or type its path in the package, such as README.md or src/main.ts.

**Outputs**

- `checksum` (text): Its SHA-256 checksum, as sha256-<hex>
- `content` (text): The file's text
- `is_truncated` (true/false): True when the file is longer than the step returns, so content holds only its start
- `package` (text): The package that was read
- `path` (text): The file's path in the package, such as /deno.json
- `size_bytes` (number): The file's size in bytes
- `url` (text): The file on jsr.io
- `version` (text): The version the file comes from

**Example output**

```json
{
  "checksum": "sha256-182d793ae7f6485419ea10ff128aafca17e06e6af92cfcb67e67ef976b29b6aa",
  "content": "{\n  \"name\": \"@std/fs\",\n  \"version\": \"1.0.19\",\n  \"exports\": {\n    \".\": \"./mod.ts\",\n    \"./copy\": \"./copy.ts\"\n  }\n}\n",
  "is_truncated": false,
  "package": "@std/fs",
  "path": "/deno.json",
  "size_bytes": 1775,
  "url": "https://jsr.io/@std/fs/1.0.19/deno.json",
  "version": "1.0.19"
}
```

### Search packages

Find JSR packages whose name or scope contains some text, such as router or hono, with exact name matches first, optionally only those marked as working on the runtimes you choose. Each result comes with its latest version, description, score and the runtimes it works on. Returns up to 100 packages.

**Inputs**

- Search for (`query`, text, required): Text to find in package names and scopes, or a scope and a name as scope/name. JSR matches names and scopes, not descriptions. For every package in one scope, use 'List a scope's packages'.
- Works on (`runtimes`, list): Only packages marked as working on every runtime chosen. Leave empty for any. One or more of: `deno`, `node` (Node.js), `bun`, `workerd` (Cloudflare Workers), `browser` (Browsers).
- Include packages with nothing published (`include_unpublished`, true/false): Include packages that exist but have never published a version, which cannot be installed. Default: `false`.
- How many to return (`limit`, number): How many packages to return, up to 100. Defaults to 20. From 1 to 100. Default: `20`.

**Outputs**

- `count` (number): How many packages are in this result
- `more_available` (true/false): True when further matches were left out
- `packages` (list): The matching packages, exact name matches first
- `query` (text): The search as JSR received it
- `search_url` (text): The same search on jsr.io
- `total_matches` (number): How many packages JSR matched by name or scope, before the runtime and unpublished filters

**Example output**

```json
{
  "count": 2,
  "more_available": true,
  "packages": [
    {
      "compatible_runtimes": [
        "deno",
        "node",
        "bun",
        "workerd",
        "browser"
      ],
      "created_at": "2024-05-24T09:01:09Z",
      "description": "Web framework built on Web Standards",
      "github_repository": "honojs/hono",
      "is_featured": true,
      "latest_version": "4.13.13",
      "name": "hono",
      "package": "@hono/hono",
      "scope": "hono",
      "score": 82,
      "url": "https://jsr.io/@hono/hono",
      "version_count": 154
    },
    {
      "compatible_runtimes": [
        "deno",
        "node",
        "bun",
        "workerd",
        "browser"
      ],
      "created_at": "2025-08-25T06:36:35Z",
      "description": "",
      "github_repository": "fedify-dev/fedify",
      "is_featured": false,
      "latest_version": "2.4.4",
      "name": "hono",
      "package": "@fedify/hono",
      "scope": "fedify",
      "score": 94,
      "url": "https://jsr.io/@fedify/hono",
      "version_count": 871
    }
  ],
  "query": "hono",
  "search_url": "https://jsr.io/packages?search=hono",
  "total_matches": 202
}
```
