# Blockscout: a self-hosted EVM block explorer you deploy yourself

> Blockscout is an open source explorer for EVM chains and rollups, written in Elixir. It is aimed at teams running their own chain or testnet who need a public explorer, and this covers deployment paths, the API, the licence, and where it is the wrong tool.

**blockscout/blockscout** — Blockchain explorer for Ethereum based network and a tool for inspecting and analyzing EVM based blockchains. 

- Repository: https://github.com/blockscout/blockscout
- Website: http://docs.blockscout.com
- Stars: 4,720 · Forks: 3,188
- Language: Elixir
- License: NOASSERTION
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/blockscout-blockscout

## What Blockscout is for, and who actually deploys it

Blockscout is a blockchain explorer for EVM chains. The README describes it as "an open-source alternative to centralized, closed source block explorers such as Etherscan, Etherchain and others", and the scope is wider than Ethereum Mainnet: it names Ethereum Classic, Optimism, Gnosis Chain, plus testnets, private networks, L2s and sidechains.

The audience follows from that. If you operate a chain that Etherscan does not index, you cannot simply point users at Etherscan. You need an explorer of your own, with your chain's genesis, your token contracts, your verified sources. Blockscout is the self-hosted option for that job. The README says it "currently supports several hundred chains and rollups", with a list at chains.blockscout.com.

There is a second audience: teams that want the explorer API rather than the web UI. Blockscout exposes an Etherscan-compatible API, which is why wallets, dashboards and internal tooling can point at a Blockscout instance instead of a commercial endpoint. That compatibility is the practical reason many integrations exist.

The project is not a hosted service. Nothing in the README offers a managed plan or a support contract. You run it, you operate its database, and you handle its upgrades.

## How Blockscout works: Elixir, Postgres and an indexer

Blockscout is written in Elixir, and the repository is an umbrella project: the top level holds a mix.exs, a mix.lock, an apps/ directory, config/, docker/, docker-compose/ and rel/. That layout is the standard shape of an Elixir/OTP release, where rel/ defines what gets packaged and apps/ holds the individual applications that make up the system.

The data flow is the usual explorer pattern. An indexer process reads blocks from your chain's JSON-RPC endpoint, writes them into a Postgres database, and the web application serves pages and API responses from that database. Verification of smart contracts is a separate workflow: a user submits source code, Blockscout compiles it and compares the result against the deployed bytecode, and the verified source is then published on the contract page.

Two consequences fall out of this design. First, the explorer's freshness depends on the indexer keeping up with the chain head; a lagging indexer shows stale balances and missing transactions. Second, the database is not a cache you can drop. It holds indexed chain history and verification records, so it grows with your chain and needs real operational care.

Background jobs, caching and the web layer all run inside the same Elixir release, which is why the deployment guides treat the application, its database and its configuration as one unit rather than as separate services you assemble.

## Installing Blockscout and reaching a running explorer

The README does not put installation steps inline. It points at the documentation and lists deployment paths: manual deployment, Docker Compose, Kubernetes, a manual backend plus old UI variant, and Ansible. Environment variables and configuration options have their own documentation pages. Pick one path and follow it there rather than improvising.

Docker Compose is the shortest route for a first look. The repository ships a docker-compose/ directory and a docker/ directory, and the documentation has a Docker Compose deployment page. A typical invocation from that directory looks like this:

```bash
docker compose up -d
```

What you should see is a set of containers coming up: the Blockscout application, a Postgres database, and the supporting services the compose file defines. The explorer UI is then reachable on the port the compose file publishes, and the API answers under the /api path on the same host.

Configuration is environment driven. The documented environment variable reference is the place to set your chain's RPC endpoint, database credentials and chain identity; the README links it as "ENV variables". Do not guess variable names, since the documentation is the authority and the names are not self-evident.

Once the instance is up, the first real use is a search. Paste a transaction hash or an address into the search box and confirm that Blockscout returns data from your chain rather than an empty page. If it returns nothing, the indexer is not reading your RPC endpoint correctly, and the environment configuration is the first thing to check.

## The Etherscan-compatible API is the part integrators care about

For many teams the API matters more than the UI. Blockscout's API is designed to be compatible with the Etherscan API, which means an existing integration that speaks Etherscan's parameters can often be repointed at a Blockscout instance by changing the base URL.

That is a meaningful reduction in switching cost. Wallets, portfolio trackers and internal scripts that already call Etherscan endpoints do not need a rewrite; they need a different host and, depending on the deployment, an API key issued by your instance. The related searches around Blockscout include "blockscout api key", which reflects how commonly the API is used as an integration surface rather than a browsing tool.

The compatibility is a surface-level contract, not a guarantee of identical behaviour across every endpoint. When you repoint an integration, verify the specific endpoints you depend on against your own instance rather than assuming parity. Rate limits, pagination and error shapes are the usual places where a drop-in swap needs a second look.

The API also sidesteps one of the explorer's operational constraints: an API consumer does not care whether the web UI is styled the way you want, only whether the indexer is current.

## Where Blockscout is the wrong choice

The clearest case against Blockscout is when you do not run a chain. If you want to inspect Ethereum Mainnet transactions, public hosted instances already exist, and deploying your own indexer to mirror Mainnet means storing and maintaining a copy of data someone else already serves. The README positions Blockscout as an alternative for chains that need their own explorer, not as a replacement for browsing Mainnet.

The second case is operational capacity. Blockscout is an Elixir application backed by a database that grows with chain history. Someone has to run it, monitor the indexer, apply upgrades and handle database growth. A team without that capacity is better served by a hosted explorer, even at the cost of control.

The third case is licence fit. The repository's licence field is NOASSERTION and the README states the project is licensed under the Blockscout Software Licence, with third-party components under their own terms. That is not a standard OSI licence such as MIT or Apache-2.0, and the README does not summarise its terms. If your organisation has a policy about which licences it accepts, read the LICENSE file before you build on it.

A fourth limitation is inherent to the design: the explorer can only show what the indexer has ingested. During a reorg, a backlog or an RPC outage on your node, the explorer lags or shows inconsistent state. That is a property of any indexed explorer, but it is worth stating plainly because users treat an explorer as ground truth.

## How Blockscout differs from Etherscan and from running your own indexer

The README names Etherscan directly as the thing Blockscout is an alternative to. The difference is not features, it is control and coverage. Etherscan is a closed source, centralized service that indexes the chains its operators choose to support. Blockscout is source-available software you deploy against a chain you choose, including private networks and testnets that no commercial explorer will index.

That difference cuts both ways. You gain coverage of your own chain and control over the data. You lose the operational simplicity of a service someone else runs, and you take on the work of keeping the indexer current.

The second alternative is the do-it-yourself indexer. A team could write its own ingestion pipeline against the chain's JSON-RPC and serve its own API. The reason not to is the surface area: contract verification with source compilation, token balances, internal transactions, and an API shaped like Etherscan's. Reproducing that is months of work, and the Etherscan-compatible API is the part that makes existing integrations work without changes. Building your own only makes sense if your requirements diverge sharply from what an explorer does.

Between those two, Blockscout occupies the middle: more work than using Etherscan, far less work than writing an explorer from scratch.

## Maintenance, upgrades and licence implications

The repository is not archived, and the last push was on 2026-09-22. Recent releases are frequent: v11.3.0 on 2026-09-10, v11.3.1 on 2026-09-16 and v11.3.2 on 2026-09-21. A CHANGELOG.md sits at the repository root, so release-by-release changes are documented in-tree rather than only in release notes.

That cadence has a cost. Frequent releases mean upgrade work, and an Elixir application with a database behind it usually means migrations. The repository includes a rel/ directory for release packaging and a docker-compose/ directory, so container-based upgrades are the path with the least custom tooling. The README does not document rollback, so plan your database backups before upgrading rather than after.

On licensing, the README states the project is licensed under the Blockscout Software Licence and points to the LICENSE file for full terms. It also notes that third-party components remain under their own licences, with details in dependency manifests and bundled notices. The repository's licence field reads NOASSERTION, which means GitHub could not classify it automatically. The practical implication is that you cannot assume MIT or Apache-2.0 terms apply. Whether the Blockscout Software Licence is acceptable for your use, particularly for a commercial or modified deployment, is a question for your own legal review; this article does not give legal advice and the README does not summarise the terms.

## Conclusion

Adopt Blockscout if you run an EVM chain, L2, sidechain or private network and need a public explorer you control, or if you want an Etherscan-style API you can query yourself. Do not adopt it if you only want to browse Ethereum Mainnet, since public hosted instances already exist, or if you need a hosted SaaS with a support contract. Before committing, verify three things: your chain's JSON-RPC endpoint answers the calls Blockscout needs, which deployment path fits your infrastructure (manual, Docker Compose, Kubernetes or Ansible), and how the Blockscout Software Licence applies to your intended use, which is a question for your own counsel rather than this article.

## FAQ

### Is Blockscout free?

The software itself is open source and the README does not describe any fee for using it. What it costs is the infrastructure you run it on: a server, a Postgres database and an RPC endpoint for your chain. The licence is the Blockscout Software Licence, so review its terms rather than assuming no conditions apply.

### What is Blockscout and what does it do?

It is a blockchain explorer for EVM chains, used to view, confirm and inspect transactions, accounts, balances and smart contracts. It also verifies and lets users interact with smart contracts, and it exposes an Etherscan-compatible API.

### How does Blockscout compare to Etherscan?

The README describes Blockscout as an open source alternative to centralized, closed source explorers such as Etherscan. The practical difference is control and coverage: you deploy Blockscout against a chain you choose, including private networks and testnets, while Etherscan is a hosted service that indexes the chains its operators support.

### What are the alternatives to Blockscout?

Etherscan is the alternative the README names, and it is a hosted, closed source service rather than something you run. The other option is building your own indexer and API against your chain's JSON-RPC, which means reproducing contract verification, token balances and Etherscan-compatible endpoints yourself.

## Sources

- [blockscout/blockscout on GitHub](https://github.com/blockscout/blockscout)
- [Issues](https://github.com/blockscout/blockscout/issues)
- [Project website](http://docs.blockscout.com)
- [README](https://github.com/blockscout/blockscout/blob/master/README.md)
- [Releases](https://github.com/blockscout/blockscout/releases)

---

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