# ord: the Rust index and explorer behind Ordinals on Bitcoin

> ord is an index, block explorer and command-line wallet for satoshi ordinals, built in Rust and backed by a synced Bitcoin Core node. It is experimental software, and its wallet design has real consequences for anyone holding inscriptions.

**ordinals/ord** — 👁‍🗨 Rare and exotic sats

- Repository: https://github.com/ordinals/ord
- Website: https://ordinals.com
- Stars: 3,966 · Forks: 1,479
- Language: Rust
- License: CC0-1.0
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/ordinals-ord

## What ord solves, and who it is actually for

Ordinal theory gives satoshis serial numbers, assigned in the order in which they are mined and preserved across transactions. The README describes the project in one line: ord is an index, block explorer, and command-line wallet. Those three roles answer three different questions. The index tracks where every satoshi sits after each block. The explorer, served by ord server and hosted at ordinals.com, renders that data as browsable pages. The wallet lets you create and manage inscriptions from a terminal.

The audience is narrow. You need a synced bitcoind node because ord builds its satoshi-location index by talking to Bitcoin Core over RPC. You need to be comfortable with a CLI. And you need to accept the README's own framing: experimental software with no warranty. Someone who wants to look at an inscription can use a hosted explorer. Someone who wants to mint one can use a hosted service. ord is for people who want the index and the keys on their own machine.

## How the index, explorer and wallet fit together

The data flow starts at bitcoind. The README states that ord requires a synced bitcoind node with -txindex to build the index of satoshi locations, and that ord communicates with bitcoind via RPC. If bitcoind runs locally under the same user with default configuration, ord finds it by reading the .cookie file. The index itself is a redb file; the justfile contains a delete-index recipe that stops the ord service and removes /var/lib/ord/*/index.redb, which tells you where the index lives on the project's own servers.

The explorer is an HTTP server built on axum and axum-server, with templates and static assets shipped in the repository. The README is blunt about its threat model: the explorer hosts untrusted HTML and JavaScript, which creates potential cross-site scripting and spoofing attacks, and the user is responsible for mitigating them. The examples directory contains files such as external-resources-are-blocked.html and navigation-to-external-pages-is-blocked.html, which suggests the server applies restrictions on what inscription content can load or link to.

The wallet is not a standalone key manager. ord relies on Bitcoin Core for private key management and transaction signing. That single design decision drives every warning in the wallet section of the README.

## Installing ord and running a first command

The README offers a pre-built binary install. This downloads and runs the project's install script, after which ord --version should print a version string.

```bash
curl --proto '=https' --tlsv1.2 -fsLS https://ordinals.com/install.sh | bash -s
ord --version
```

Homebrew is also supported. The README gives this as a single command, and the ord binary ends up on your PATH the same way.

```bash
brew install ord
```

Building from source is the path the README documents in most detail. On Debian-derived distributions it lists build dependencies, then a Rust toolchain, then a release build. Note the version constraint: the README says ord requires rustc 1.79.0 or later, while Cargo.toml sets the workspace rust-version to 1.89.0. Trust the manifest if you are building the current tree.

```bash
sudo apt-get install pkg-config libssl-dev build-essential
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
git clone https://github.com/ordinals/ord.git
cd ord
cargo build --release
./target/release/ord --version
```

A Docker image can be built from the repository root. The Dockerfile uses a two-stage build, compiling with cargo build --bin ord --release and copying the binary into a debian:bookworm-slim image.

```bash
docker build -t ordinals/ord .
```

Before any of this produces useful output, bitcoind must be synced with -txindex. That sync is the real cost of a first run, not the install.

## The wallet warnings you should read twice

The README's wallet section is the most consequential part of the documentation. It states plainly that Bitcoin Core is not aware of inscriptions and does not perform sat control, and that using bitcoin-cli commands and RPC calls with ord wallets may lead to loss of inscriptions. In other words, the tool that signs your transactions has no concept of the asset you are trying to protect.

A second warning concerns wallet loading. ord wallet commands automatically load the ord wallet given by the --name option, which defaults to 'ord'. After running an ord wallet command, an ord wallet may be loaded in Bitcoin Core, with whatever that implies for subsequent operations.

A third warning is about scope. Because ord has access to your Bitcoin Core wallets, the README says ord should not be used with wallets that contain a material amount of funds, and that ordinal and cardinal wallets should be kept segregated. That is not a suggestion about hygiene; it is the project telling you that the blast radius of a mistake includes your ordinary bitcoin. If you want one wallet for everything, ord is the wrong tool.

## Security, hosting and the explorer's threat model

Running ord server means serving content that strangers paid to inscribe. That content can include HTML and JavaScript. The README says the explorer hosts untrusted HTML and JavaScript and that this creates potential security vulnerabilities, including cross-site scripting and spoofing attacks, with the user solely responsible for understanding and mitigating them. The repository points to docs/src/security.md for details rather than resolving the problem in the README itself.

The examples directory is worth reading before you expose a server to the internet. Files named external-resources-are-blocked.html and top-navigation-is-blocked.html indicate that certain classes of content are neutralised in the rendering path. That is a mitigation, not a guarantee. If you run ord server on a public hostname, treat the browser as the boundary and assume an inscription author is adversarial.

There is a second operational cost that the README does not dwell on: the index. The justfile's delete-index recipe shows the project deleting index.redb when it needs to rebuild, which is the standard escape hatch when an index goes bad. Rebuilding means re-reading chain data, and that takes time proportional to what you are indexing.

## Alternatives and where ord sits among them

The obvious alternative is a hosted explorer or marketplace. Those give you a browser and an API without a node, an index, or a wallet. The difference in approach is custody and completeness: a hosted service decides what you can see and what you can do, while ord gives you the raw index and the signing path through your own Bitcoin Core. If your goal is to look up a single inscription, running ord is a large amount of infrastructure for that answer.

A second alternative is to build directly against Bitcoin Core and the BIP. The repository ships bip.mediawiki, which the README describes as a technical description of the assignment and transfer algorithm. If you need satoshi tracking inside your own application, implementing the algorithm yourself is possible, but you inherit the testing burden. ord's own contribution guidelines describe three categories of tests, unit, integration and fuzz, and a mocked Bitcoin Core instance in crates/mockcore so tests can run without a real node. Reproducing that harness is the hidden cost of the roll-your-own route.

A third option is to use ord only as an index and skip the wallet entirely. Nothing forces you to use ord wallet, and given the README's warnings about Bitcoin Core's lack of sat control, that split is defensible: index with ord, sign with tooling that understands inscriptions.

## Maintenance, licensing and upgrade cost

The repository is not archived and the last push was on 2026-09-12. Recent releases are 0.29.0 on 2026-08-05, 0.28.0 on 2026-08-02 and 0.27.1 on 2026-03-29, and Cargo.toml carries version 0.29.0. The gap between 0.27.1 in March and two releases in early August suggests bursts of activity rather than a steady cadence, so pin a version and read the changelog before upgrading.

Upgrade cost has two components. The binary is easy to replace. The index is the expensive part: schema changes can force a rebuild, and the project's own delete-index recipe exists precisely because deleting index.redb is a normal operation. Budget for re-indexing time on any upgrade that touches storage.

The licence is CC0-1.0, applied at the workspace level in Cargo.toml. CC0 is a public-domain dedication rather than a permissive software licence in the MIT or Apache sense, which is unusual for a Rust binary and worth flagging to whoever reviews dependencies in your organisation. The README also notes that the project is community funded, with the current lead maintainer's work funded entirely by donations. That is a maintenance risk to weigh, not a defect.

## Conclusion

ord suits engineers who want to run their own Ordinals index and explorer, and who already operate a synced Bitcoin Core node with -txindex. It is the wrong tool for anyone who wants a hosted wallet: the README warns that Bitcoin Core does not perform sat control and that using bitcoin-cli with ord wallets may lead to loss of inscriptions. Before adopting it, verify that your bitcoind has -txindex enabled, that your rustc is at least 1.89.0 if you build from source, and that you can segregate ordinal and cardinal wallets.

## FAQ

### What is ord?

ord is an index, block explorer, and command-line wallet for Bitcoin ordinals, written in Rust. The README describes it as experimental software with no warranty.

### Does ord need a Bitcoin Core node?

Yes. The README states that ord requires a synced bitcoind node with -txindex to build the index of satoshi locations, and that ord communicates with bitcoind via RPC.

### How do I install ord?

The README gives a pre-built binary install via the project's install.sh script, a Homebrew formula, a Docker build, and a source build with cargo build --release. After installing, ord --version should run.

### Can I use ord wallet with my existing Bitcoin Core wallet?

The README warns against it. Bitcoin Core does not perform sat control, and using bitcoin-cli commands or RPC calls with ord wallets may lead to loss of inscriptions. It also says ord should not be used with wallets holding a material amount of funds.

## Sources

- [License: CC0-1.0](https://github.com/ordinals/ord/blob/master/LICENSE)
- [ordinals/ord on GitHub](https://github.com/ordinals/ord)
- [Project website](https://ordinals.com)
- [README](https://github.com/ordinals/ord/blob/master/README.md)
- [Releases](https://github.com/ordinals/ord/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ordinals-ord