Talero mainnet public docs

Official entry points

These are the main public URLs associated with the Talero ecosystem. Public services can be rate-limited, adjusted, or fronted by dedicated infrastructure. Production workloads should rely on your own node where possible.

Public RPC is best-effort. If you need stable throughput, unredacted data, or operational guarantees, run your own node and keep the edge under your control.

Quickstart

Start with the public JSON-RPC endpoint for basic integration checks, then move to a self-hosted node for production traffic. Do not assume public limits, latency, or redaction policy are suitable for backend workloads.

Public JSON-RPC examples

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":2,"method":"eth_blockNumber","params":[]}'

curl -sS -X POST https://rpc.talero.info/rpc \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":3,"method":"talero_safeModeStatus","params":{}}'

Local operator checks

curl -sS http://127.0.0.1:8547/health

curl -sS -X POST http://127.0.0.1:8547/rpc \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":4,"method":"talero_getNetworkInfo","params":{}}'

curl -sS http://127.0.0.1:8547/metrics | head

Keep /metrics private unless you explicitly want to publish operational telemetry. The local examples assume the default node HTTP port 8547.

Public interface guides

The Talero node exposes both a general HTTP surface and a JSON-RPC surface. Those two contracts are now documented on dedicated pages so the home page stays concise and avoids duplicating endpoint-level detail.

These two pages are the source of truth for the public application surface. The home page now keeps only high-level navigation and operational safety context.

Start with the Node HTTP Surface guide if you are integrating through REST, health checks, or SSE. Start with the Public-safe RPC guide if you are integrating through JSON-RPC.

Safety model

Talero treats public RPC as a hardened surface, not as a fully trusted operator channel. Public deployments can mask data, deny certain methods, or tighten limits when network conditions deteriorate.

Public privacy hardening

• Public mode can mask balances and optionally nonces on public-facing requests.
• Proof and storage calls can be denied on public edges to reduce scraping and abuse.
• REST responses for address-centric routes can be redacted according to the active privacy policy.

Safe mode

• Safe mode watches peer count, finality lag, fork activity, reorgs, and chain stall signals.
• When risk rises, the node can tighten timeouts and concurrency and deny heavy public methods.
• Public status is visible through talero_safeModeStatus; override controls are intentionally not documented here.

Network health and watchtower

• talero_networkHealth and /api/v1/network/health expose aggregated data only, with no IPs or peer IDs.
• talero_watchtowerStatus and /api/v1/watchtower/status are suitable for public status pages.
• Full peer-debug and incident-response controls belong on private operator surfaces only.

Finality surfaces

• talero_getFinalityReceiptBundle is the public-safe compact finality surface for transaction receipts.
• Full finalized proof bundles and admin publication flows are not part of this public guide.

Running a node

Talero supports multiple node roles. Public documentation should stay focused on safe deployment patterns rather than publishing role-specific secrets or private infrastructure wiring.

Node roles

Recommended deployment pattern

• Start from docker-compose.mainnet.yml in the Talero node repository.
• Keep HTTP RPC on 127.0.0.1:8547 by default unless you intentionally build a hardened public edge.
• Expose P2P on the required TCP and UDP ports separately from the RPC edge.
• Put Nginx or another reverse proxy in front of any public RPC deployment.
• Keep /metrics and /prom/metrics private.
• Enable hardening controls such as TALERO_PRIVACY_ENABLED=1, TALERO_HONEYTRAP_ENABLED=1, and TALERO_SAFE_MODE_ENABLED=1.
• Use TALERO_RPC_PUBLIC_MODE=1 only on a deliberately hardened public-facing node.

Role-specific guides

Minimal bring-up

docker compose -f docker-compose.mainnet.yml up -d

curl -sS http://127.0.0.1:8547/health

curl -sS -X POST http://127.0.0.1:8547/rpc \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":5,"method":"eth_chainId","params":[]}'

Never publish signer endpoints, safe-mode bypass tokens, validator key material, raw admin ACLs, or unreviewed internal IP addresses on a public documentation site.

Mining pool

The public pool entry point is https://pool.talero.info. Pool UX and mining-facing operations can evolve independently from the base node HTTP surface.

• Use the pool site for the current public workflow and operator-facing guidance.
• Mining-related RPC exists in the node, but deployment policy is operator-specific and should not be inferred from a public marketing page.
• Pool internals, worker controls, and private operational endpoints are intentionally not documented here.

Protocol parameters

The following values come directly from the Talero node codebase and are safe to describe publicly. Some network parameters can still change through explicit upgrades or deployment-specific configuration.

The node code supports a post-quantum transaction path and exposes the effective capability summary through RPC. Query the node instead of relying on static assumptions about active signing policy.

FAQ

Why are admin or trusted-only methods not listed here?

Because this is a public site. Talero separates public-safe surfaces from admin and trusted control paths, and the public documentation follows that same boundary.

Should I build production workloads on the public RPC?

No. Use the public RPC for light usage, testing, and quick inspection. Run your own node for production, private integrations, and unredacted operational access.

Why do some balance or proof calls look masked or denied?

Public privacy hardening can mask balances and deny proof or storage reads on public edges. Use a private node if your workload requires full raw access.

How do I inspect finality safely from public interfaces?

Start with talero_finalizedHead, talero_finalityEstimate, talero_getCheckpoint, and talero_getFinalityReceiptBundle.

How do I discover current chain identity?

Query eth_chainId, talero_genesisHash, and talero_getNetworkInfo against the environment you are actually using.

Should I expose metrics on the public internet?

Usually no. Metrics are valuable for operators, but they also reveal operational details. Keep them private unless you have a deliberate reason to publish them.