Production-Grade Bitcoin Inscriptions Service: UTXO Handling

Inscription Minting Service Overview

Building a Bitcoin inscriptions service begins not with the UI but with UTXOs and the commit-reveal pattern. According to Ordinals documentation, inscriptions are created using a commit-reveal pattern. Our bespoke Ordinals API endpoint handles inscription queries with sub-second latency. An inscriptions service requires understanding witness data limits. Inscriptions are not smart contracts—they are data embedded in SegWit transactions and bound to specific satoshis via the Ordinals numbering protocol. Creating a service that reliably creates, tracks, and transfers such records is a task that cannot be solved with standard Bitcoin libraries "out of the box." Our team has 7+ years in Bitcoin infrastructure and 20+ inscription projects. We take on such projects end-to-end: from architecture design to deployment and monitoring. After launch, we provide support: node monitoring, indexer updates, fee estimation optimization. Code warranty—3 months. Savings from using a custom indexer can reach $5,000 per month on API requests, and Redis caching adds up to $3,000 per month in savings. Typical development cost ranges from $15,000 to $50,000 depending on features. Typical fees for minting a collection of 1,000 inscriptions are 0.5–1 BTC. Get a free consultation on your service architecture.

Bitcoin Inscriptions Service Architecture

An inscription is created via the commit-reveal pattern using two transactions. In the commit transaction, a P2TR (Pay-to-Taproot, BIP-341) output is formed with data inside the witness script. The script structure is OP_FALSE OP_IF ... OP_ENDIF with a protocol marker, content-type, and data split into 520-byte chunks. This branch is never executed, making the data witness information rather than executable code. The technical specification is described in BIP-341. The maximum inscription size is about 4 MB (block limit), but it's safer to limit to 380 KB to fit any block. The reveal transaction spends this output, disclosing the script on the blockchain. The inscription is bound to the first satoshi of the first input of the reveal transaction by ordinal theory.

Why Is It So Easy to Burn an Inscription on Transfer?

The most common production mistake is mixing regular UTXOs with UTXOs carrying inscriptions. If an inscribed sat enters a transaction input in the wrong position, ordinal theory considers it spent, and the inscription is irreversibly lost. Rule: always check UTXOs via ord API before including them in a transaction. We guarantee that every UTXO is validated before becoming an input. UTXO management is a core competency of our team. Our team leverages hierarchical deterministic (HD) wallet derivation per BIP-86 and implements robust error handling for unspent transaction output selection.

Why Is PSBT Important?

To integrate with user wallets (Unisat, Xverse, OKX Wallet), transactions are built as Partially Signed Bitcoin Transactions (BIP-174). The server creates a PSBT with correct referrer UTXOs, scripts, and control blocks, and the wallet signs it. PSBTs are 3x safer than raw transactions when signing because they check the consistency of inputs and outputs. Plus—transparency: the user sees exactly what they are signing.

Custom Indexer vs Third-Party APIs

Third-party APIs (Hiro, OrdinalsBot) are convenient for prototyping, but in production they introduce delays and request limits. Custom indexer is 2-3x faster than third-party APIs for collection history queries. This is critical for marketplaces and launchpads where every extra millisecond means lost users. Additionally, a custom indexer with Redis caching reduces response time by 2-3x compared to direct API calls.

Architecture of a Bitcoin Inscriptions Service

Step-by-Step Inscription Creation Process

1. Generate key pair and derivation path per BIP-86.
2. Build envelope script with data split into 520-byte chunks.
3. Create P2TR output with tapscript containing the script.
4. Build commit transaction with this output.
5. Build reveal transaction spending the commit output and revealing the script.
6. Sign PSBT with wallet and broadcast.

import * as bitcoin from 'bitcoinjs-lib'; import { ECPairFactory } from 'ecpair'; import * as ecc from 'tiny-secp256k1'; const ECPair = ECPairFactory(ecc); async function createInscription( content: Buffer, contentType: string, feeRate: number, // sat/vByte recipientAddress: string, ): Promise<{ commitTx: string; revealTx: string }> { const keypair = ECPair.makeRandom({ network: bitcoin.networks.bitcoin }); // Build envelope script const envelope = bitcoin.script.compile([ bitcoin.opcodes.OP_FALSE, bitcoin.opcodes.OP_IF, Buffer.from('ord'), bitcoin.opcodes.OP_1, Buffer.from(contentType), bitcoin.opcodes.OP_0, // data split into 520-byte chunks ...chunkData(content, 520), bitcoin.opcodes.OP_ENDIF, keypair.publicKey.slice(1), // x-only pubkey for Taproot bitcoin.opcodes.OP_CHECKSIG, ]); // Create P2TR output with inscription in tapscript const scriptTree = { output: envelope }; const p2tr = bitcoin.payments.p2tr({ internalPubkey: keypair.publicKey.slice(1), scriptTree, network: bitcoin.networks.bitcoin, }); // Commit TX sends funds to p2tr.address // Reveal TX spends this output, revealing the script // ... } 

PSBT and Signing

const psbt = new bitcoin.Psbt({ network: bitcoin.networks.bitcoin }); psbt.addInput({ hash: utxo.txid, index: utxo.vout, witnessUtxo: { script: p2tr.output!, value: utxo.value, }, tapLeafScript: [{ leafVersion: 0xc0, script: envelope, controlBlock: p2tr.witness![p2tr.witness!.length - 1], }], }); psbt.addOutput({ address: recipientAddress, value: 546, // dust limit }); const psbtBase64 = psbt.toBase64(); 

Indexing and Working with Existing Inscriptions

The Ordinals indexer provides a JSON API (ord server):

GET /inscriptions/{address} GET /incription/{incription_id} GET /sat/{sat_number} 

For high-load production, we build a custom indexer on top of the ord database (SQLite or PostgreSQL) with Redis caching. This provides stable RPS and independence from external APIs. Our inscription minting service guarantees atomicity through meticulous PSBT handling. BRC-20 integration is also implemented via a custom indexer.

Formats and Limitations

What You Get as a Result