Exfer Documentation

Exfer is a public blockchain built for machines, not people, to spend on.

When an autonomous agent — a trading bot, a service that pays per API call, an IoT device buying its own electricity — needs to pay another agent, the conventions humans have learned to tolerate stop working. A wallet UI doesn't fit. A fee auction doesn't fit. A smart-contract VM whose execution cost depends on global state doesn't fit. An agent has to construct a transaction, compute its exact cost in advance, and know with certainty that it will validate — no human present to retry, raise the fee, or read an error.

Exfer is what's left when you design a chain around that constraint.

• No fee auction. Fees are fixed per transaction, FIFO within a band, protocol-enforced minimum. An agent can pre-fund itself accurately.
• No gas estimation. Costs are statically computable from the serialized transaction. There is no Turing-complete VM and no global mutable state to simulate against.
• Total functional scripting. Every spending condition is expressed in Exfer Script — a combinator language in which every script terminates and every cost is bounded before execution. HTLC, multisig, vault, escrow, and delegation are first-class CLI commands, not contracts you write and deploy.
• Extended UTXO. The data model is Bitcoin-style — each transaction consumes and creates discrete outputs — so reasoning about state is local, parallel, and reentrancy-free.
• Argon2id memory-hard proof-of-work. Mining is CPU-friendly and resistant to the kind of ASIC concentration that locks small operators out.
• 10-second target block time. Predictable confirmation cadence. Retargets every 4 320 blocks.

The result is a chain where an agent's day looks like: fetch UTXO → build tx → compute exact fee → sign → submit → confirmed, with no surprises in between.

Don't want to read all this? Use an AI agent

Exfer is designed for machines. The docs are no different — if you'd rather have an LLM read them and answer your specific question, here's a prompt that primes Claude, ChatGPT, Cursor, or any agent that can browse URLs to be an Exfer expert.

You are an expert on Exfer, a public proof-of-work blockchain designed
for machine-to-machine payments. Help the user with their Exfer-related
question.
AUTHORITATIVE REFERENCES (load these before answering):

Protocol spec:    https://exfer.org/
CLI cookbook:     https://exfer.org/SKILL.html
JSON-RPC docs:    https://doc.exfer.site/rpc/
Source code:      https://github.com/ahuman-exfer/exfer

KEY FACTS YOU SHOULD KNOW:

Exfer is NOT Bitcoin-compatible. Don't assume Bitcoin Core RPC names.
Extended-UTXO model. Scripts are total functional combinators —
they always terminate, and their cost is static.
The JSON-RPC interface has exactly 7 methods: get_block_height,
get_block, get_transaction, get_balance, get_address_utxos,
get_script_utxos, send_raw_transaction.
1 EXFER = 100_000_000 exfers. Target block time 10s.
Coinbase maturity 360 blocks.
For automation: use --json on every CLI command, and pass the wallet
passphrase via EXFER_PASS + --passphrase-env.
Native script patterns (no smart-contract VM needed): HTLC, multisig
(2-of-2, 1-of-2, 2-of-3), vault, escrow, delegation. All exposed as
exfer script <pattern>-{lock,spend,claim,reclaim,...} CLI commands.

When you give CLI examples, prefer the patterns shown in SKILL.html.
When you give RPC examples, match the parameter shapes documented at
doc.exfer.site/rpc/. If the user is doing exchange / wallet /
explorer integration, point them at doc.exfer.site/integrate/.
The user's question follows:

Where to go from here

This site is a community-maintained reference and live explorer. Pick the entry point that matches what you're doing.

A few quick facts

• Genesis block: d7b6805c8fd793703db88102b5aed2600af510b79e3cb340ca72c1f762d1e051
• Network ports: P2P 9333, JSON-RPC 9334 (optional)
• Units: 1 EXFER = 100 000 000 exfers
• Initial block reward: 100 EXFER, halving roughly every 2 years (6 307 200 blocks), floor at 1 EXFER
• Coinbase maturity: 360 blocks (~1 hour)
• Live community RPC nodes: see Live nodes, with a "try it" widget on every method in the JSON-RPC reference so you can call any endpoint without setting up a node first

How this site is organized

The sidebar follows the typical user journey:

• Getting Started — install the binary, create a wallet, send and receive payments. About 30 minutes from zero.
• Run a Node — install, sync, run as a system service, back up, troubleshoot.
• Mining — what Argon2id mining means in practice, solo, and pools.
• Script patterns — HTLC, multisig, vault, escrow, delegation walkthroughs.
• Integrate Exfer — exchange, wallet, and explorer integration recipes built on the JSON-RPC surface.
• Tools — live community-node dashboard, web wallet, block explorer.
• Reference — JSON-RPC API with try-it widgets, protocol spec link, CLI command list.
• About — FAQ, glossary, contributing.

Caveats

• Community-maintained, not officially affiliated. Authoritative sources are the upstream EXFER.md (protocol spec) and SKILL.md (CLI cookbook). This site renders them, plus original content, for convenience.
• Public RPC nodes are best-effort and rate-limited. For production integrations, run your own node.
• No formal security audit at this writing. The project is young. Treat substantial value accordingly — see Backup & recovery and Vault.