use.bsv.tools

For AI-assisted founders and product builders

Add payments, private data, and proof with one BSV starter.

Copy the AI-ready reference into your coding agent, pick one product moment, and start from a maintained BSV starter with wallet login already in the path.

Run starter
  • No signup screen first
  • Charge per use
  • User-held private data
  • Proof outside your database
Private customer memory Encrypted
brand-voice.note buyer-profile.note launch-plan.note
The app remembers without owning the profile.
Signed creation proof Verified
Created by wallet 9f8e2d...b7a1c3
Authorship can travel outside one app.

Who this is for

People who know the product, not necessarily the protocol.

Proof before plumbing

Start with a product moment people can understand.

Each example keeps the BSV value visible in the app: the user pays at the moment of value, carries private state through a wallet, or gets a proof that does not depend on your database.

Paid AI action

What they built: A lead-research or content action that charges only when the expensive result runs.

Why BSV mattered: Tiny payment before work, without forcing a subscription first.

Customer memory 3 private notes Wallet can decrypt

Private customer memory

What they built: An assistant that remembers preferences without turning them into app-owned profile data.

Why BSV mattered: Private records stay tied to the user's wallet permissions.

Launch asset Signed by creator Proof page ready

Signed creation proof

What they built: A shareable proof page for a design, AI artifact, license, or approval.

Why BSV mattered: Authorship and consent remain verifiable outside the original app.

Builder proof

“Hands-on development with the BSV SDK — build real applications with transactions, messaging, payments, and overlay services.”

Metanet Academy Student Visit Metanet Academy
MetanetApps catalog

AuthSig

AuthSig turns signed identity into a product moment for an AI-saturated internet: verify who stands behind a photo, document, or message.

View AuthSig on MetanetApps

LLM reference

Give your coding agent the right starting point.

Choose the closest product moment, copy the reference, and ask for one working slice. The prompt keeps the wallet behavior real while translating BSV into app outcomes.

Paid AI API prompt 

        

      


      

        

          
Start here

          
Run the starter when you are ready to touch the real wallet flow.

          
Start with Node and a local BRC-100 wallet. The starter checks wallet access, then walks through payment, encrypted memory, and signature proof in one small app.

        

        

          

            1. Have Node ready
            Node 18+ and npm are enough for the starter.
          

          

            2. Open your wallet
            Metanet Client or another BRC-100 wallet should own localhost 3321/2121.
          

          

            3. Run preflight
            The command checks auth, mainnet, crypto, payment readiness, and identity key access.
          

          

            git clone https://github.com/p2ppsr/use.bsv.tools.git && cd use.bsv.tools/starter && npm install && npm run preflight && npm run dev
            
          

        

      


      

        

          
First win

          
A real wallet-backed first win.

          
The starter shows a readable success state for each path, with JSON details available when you want to inspect what happened. The point is simple: charge a few sats, save encrypted state, and verify a signature through your wallet.

        

        

          
Wallet preflightPorts, Origin headers, app ownership, auth, network, and conflict guidance.

          
Real wallet loopDerived key, encrypt/decrypt, sign/verify, and identity-key readiness.

          
Paid APIAuthFetch plus BSV auth/payment middleware, with a real wallet-created payment.

          
Private MemoryWallet encrypt/decrypt, list, reveal, and delete encrypted records.

          
Creation ProofWallet hash, sign, derived public key, and verify signature.

          
QA loopback gateStrict BRC-100 loopback wallet covering crypto and payment middleware.

        

      


      

        

          
After the starter

          
Choose the first BSV-powered behavior your app should prove.

          
Start with one useful behavior: software that earns, remembers, or verifies something without bolting on accounts, billing, or proof after the fact.

        


        

          

            

              01
              10 min after wallet setup
            

            
Paid AI API

            
Start from the working AuthFetch/payment middleware path and swap in the expensive API work you want to charge for.

            
    
              
  • Wallet auth instead of signup
    • 
              
  • Payment before expensive work
    • 
              
  • Visible revenue in the flow
    • 
            

            
          


          

            

              02
              12 min after wallet setup
            

            
Private AI Memory

            
Start from wallet-owned records with create/list/read/delete states intact.

            
    
              
  • Encrypted app records
    • 
              
  • Portable user identity
    • 
              
  • No app-owned profile silo
    • 
            

            
          


          

            

              03
              15 min after wallet setup
            

            
Creation Proof

            
Start from the wallet-backed signature and add storage, sharing, licensing, or paid unlock.

            
    
              
  • Signed provenance
    • 
              
  • Shareable proof page
    • 
              
  • License or unlock payment
    • 
            

            
          

        

      


      

        

          
Why BSV

          
Make value a feature, not a billing project.

          
Most developer platforms start with accounts, dashboards, API keys, invoices, and a pile of user data the app has to custody. BSV flips the starting point: the wallet can carry identity, permissions, payment ability, private records, and signatures into the app.

        

        

          

            01
            
Charge for work as it happens

            
Paid API calls, AI runs, file unlocks, and premium actions can settle at tiny values without forcing a subscription gate before the user gets value.

          

          

            02
            
Let users own the state

            
Encrypted records and wallet-mediated permissions let a useful app remember things without turning every profile into another app-owned silo.

          

          

            03
            
Prove creation and consent

            
Signatures and durable hashes make authorship, licensing, approval, audit trails, and AI artifact provenance visible outside one vendor database.

          

          

            04
            
Compose with agents

            
Start from a working slice, then ask an agent to extend one useful path while preserving wallet auth, payment, private data, or proof.

          

        

      


      

        

          
Use the tools

          
The minimum kit to touch first.

        

        

          
            01
            Run starter
            Clone, preflight, dev server, first wallet-backed win.
          
          
            02
            Wallet auth
            Reference docs after local wallet preflight passes.
          
          
            03
            Payments
            Understand the low-value mainnet flow behind the starter.
          
          
            04
            Private data
            Keep the starter's visible states while swapping APIs.
          
          
            05
            Hard questions
            Pressure-test BSV claims, tradeoffs, and common objections with linked sources.