Your own node.Your own client.Three commands.

No API keys from anyone. Run a Snapchain read node, open Fiddy through it, and add your own Hermes agent. You furnish the compute. You own the stack.

The easiest way in

Give it to your agent.

Paste this into [CC], Codex, Hermes, or any agent with a shell. The linked guide has the steps, prices, and mistakes to avoid.

I want my own copy of Farcaster. Before you start, ask me where I want to run my node: (a) my own computer, (b) a server I already have, or (c) a new cloud server you provision for me. Prices I was shown for a new cloud server (confirm the current price with the provider first, cloud prices change): about $285/month on AWS, about $350/month on GCP, about \u20ac120/month on Hetzner, about $190/month on OVH. For each option, tell me its cost and the disk it needs (about 2 TB while it downloads), then wait for my choice and my written approval before spending anything. Then follow https://fiddy.fun/client/skill.md. The first download is about 468 GB and takes many hours, so the machine must stay on. If anything else costs money, give me the monthly price and ask me first. Never ask for my seed phrase.
or do it by hand: see the 3 commands ↓

Three commands. That’s the setup.

Run these from the cloned Fiddy repo, with bin on PATH.

1 · Provision fiddy provision --aws Create cloud compute. Use --ssh you@server for a box you have.
2 · Node fiddy node up Install and sync Snapchain. --network hypersnap selects the other network.
3 · Client fiddy client up Boot Fiddy pointed at your node.

Need the server first? A cloud server is a recurring bill: AWS is about $285/month; GCP is about $350/month with a $300 new-user credit. New AWS accounts can wait 0-2 days for verification, so GCP is the alternative.

~914Mmessages synced in our own verified full-node run
Snapchain v0.14.3latest release, checked 25 Oct 2026
0 API keysyour compute, your reads, your writes
1Provision

Get a server, without guessing the size.

Check free disk space before any install. A read node needs 4 vCPU, 16 GB RAM, and 2 TB free disk on Ubuntu 22.04 or newer. It downloads about 468 GB, peaks at about 1.66 TB while unpacking, then settles near 597 GB before new blocks are added. Under 1 TB free, never start a local node: use the free public relay or the managed card, $320/month.

A full disk starts the download over.

A too-small disk fills, the node restarts, and it re-downloads from chunk 1 until the disk fills again. Pre-check the space; do not retry the same install. Free space or move to a computer with 2 TB free before running it again.

Get the CLI with git clone https://github.com/ivcained/fiddy && cd fiddy. The bin/fiddy script is the whole tool. Put it on PATH with export PATH="$PWD/bin:$PATH".

# get the CLI, then put it on PATH
git clone https://github.com/ivcained/fiddy && cd fiddy
export PATH="$PWD/bin:$PATH"
2Choose where you are sitting

Way 1 · From your laptop

Mac, Windows, or Linux

Everything runs from your own terminal. The CLI drives the server over SSH for you. Create the machine first, with one click or one command.

# in CloudShell, or any terminal with the AWS CLI configured:
curl -fsSL https://raw.githubusercontent.com/ivcained/fiddy/main/scripts/aws-deploy.sh | bash
# install fiddy + Herdr/Ovis console locally (no laptop-sized node):
curl -fsSL https://fiddy.fun/client/install.sh | bash
# then back in your own terminal, inside the cloned repo:
fiddy provision --ssh ubuntu@<your-new-ip>   # register the box the script printed
fiddy node up       # install and sync the node over SSH
fiddy client up     # client on your laptop, tunneled to your node
herdr                 # or: Fiddy buttons + built-in Grafana in Ovis

Way 2 · Inside the VPS

You already SSH’d into a server

Skip provision entirely. You already have the machine. One line does the rest.

# on the server itself:
curl -fsSL https://fiddy.fun/client/install.sh | bash

That clones the repo, puts fiddy on PATH, installs the Herdr/Ovis console, and starts a node if this server does not already have one. Then run fiddy client up --tunnel when you want the client. In Ovis, press Cmd/Ctrl+Shift+K and type Fiddy for node buttons; the Grafana button embeds the real dashboard beside the terminal with no AI key.

The one wrong move is fiddy provision on the server. Provisioning runs from a machine that talks to the cloud, never on the machine being provisioned.

Way 1 provisions. Way 2 runs.

Other providers: same three commands, your pick
# AWS, needs the aws CLI configured, about $285/month list:
fiddy provision --aws

# Hetzner CCX33 + 2 TB volume, about €120/month, token from console.hetzner.cloud:
fiddy provision --hetzner

# OVHcloud Public Cloud b3-16 + 2 TB volume, about $190/month:
fiddy provision --ovh

# Or any server you already have:
fiddy provision --ssh ubuntu@203.0.113.10

Hetzner and OVH paths are scripted against their API docs but not yet battle-tested. They fail loudly with the provider’s own error if anything drifts. OVH credentials come from api.ovh.com/createToken. A 2 TB box at any Hetzner, Contabo, or OVH-class host typically runs $50 to 120/month. Infra-as-code people: the same validated GCP config ships as a Terraform module in terraform/gcp-read-node/. Run terraform apply and it prints the next commands.

Every scripted path creates a 4 vCPU, 16 GB machine with about 2 TB disk and Docker preinstalled, then saves the target to ~/.fiddy/config. The AWS path also generates an SSH keypair into ~/.fiddy/ and locks the security group down. SSH and the node API answer your IP only. Gossip ports stay open to the network so your node can talk to peers.

If the outside world cannot reach your copy

Your provider's firewall is blocking the network connection. Open port 3382 over UDP to the network; allow ports 3381 and 3383 over TCP only from your own IP for the HTTP and gRPC APIs.

What the compute costs

You pay your provider directly. Fiddy does not add a fee.

  • Your own machineFreeUse hardware you already have, if it meets the disk and memory requirements.
  • Hetzner~€120/moCCX33 with a 2 TB volume. New accounts are capped at 1024 GB volumes, fine once your quota is raised.
  • OVHcloud~$190/mob3-16 with a 2 TB volume.
  • AWS~$285/moThe default path. Its root volume can simply be 2 TB, which is part of the price difference.
  • GCP~$350/moTested end to end by us. $300 new-user credit. Set a reminder to delete the VM.

New AWS account? Read this first.

CloudShell can stay locked for 0-2 days during verification. GCP is the alternative, with a $300 new-user credit and about $350/month list price after credit. The same AWS one-liner also runs from any terminal after aws configure.

If your hosting company caps your disk: new accounts can be limited to 1 TB, which cannot safely finish the first boot. Ask support to raise the limit to 2 TB, pick a different company, or start on the public relay and move later. Do not retry against the same cap.

Prefer no setup? Managed by Fiddy is $320/month. Prefer a guided self-host page? Open fiddy.fun/client/deploy.

2Node

Sync the network yourself.

fiddy node up installs Docker and the official Snapchain bootstrap on your server, then starts syncing. You now run a read node: it follows the chain, stores the full state, and serves HTTP on :3381 and gRPC on :3383. Anyone can run one. No permission, no API keys.

Want an agent to drive instead? Use the agent hand-off at the top. Its linked guide is written for agents, with the steps, prices, and mistakes to avoid.

On Linux the CLI installs the Docker engine itself through get.docker.com, adds you to the docker group, and asks you to log back in once. There is no Docker Desktop on a headless box. On macOS it offers Docker Desktop instead. The CLI is bin/fiddy: run export PATH="$PWD/bin:$PATH" after cloning, or every command says fiddy: command not found.

fiddy node up      # install, start, wait for the API to answer
fiddy node status  # sync progress
fiddy node logs    # tail the node
fiddy node dashboard # Grafana at localhost:3000 through an SSH tunnel
fiddy node autoupgrade on # weekly upgrades, Tuesday 03:00

Autoupgrade is off by default. The upstream job ends with a host-wide Docker prune. That is fine on a dedicated box, never on a shared one.

Read nodes vs validators, and where your casts go

Validators propose and vote on blocks. Only keys in the validator set can. Read nodes do everything else, including accepting writes.

When you submitMessage to your read node, it validates the message and gossips it to validators. A read node has no mempool of its own. A success response means “valid, accepted for relay,” not “in a block.” Confirm inclusion by watching for a MERGE_MESSAGE event or querying the message back.

Under heavy network load a gossiped message can drop and need resubmitting. The client can fall back to submitting at a validator endpoint, and this tutorial shows the trade-off when it matters.

Downloading the whole history: 5,690 pieces, about 468 GB total. At the measured 10-20 MB/s, this takes many hours. Plan for overnight on a slow disk.

0%

Your computer is downloading the whole history of what everyone has ever posted. No exact finish time yet. At 10-20 MB/s this takes many hours.

You can close this and come back. It keeps going on its own.

34%

About a third is down. It is pulling 10-20 megabytes every second. Roughly 300 GB is left. The speed depends on your connection and disk, so plan for overnight.

You can close this and come back. It keeps going on its own.

99%

The download finished. Now it unpacks everything into working space. That step needs the full 2 TB free at once, then it shrinks to about 597 GB. A few more minutes.

You can close this and come back. You're nearly there.

Your copy will not answer any requests until the whole history is downloaded and unpacked. That is normal, not broken.

If your copy is not answering yet

A brand-new copy refuses every request until the whole history finishes downloading and unpacking, which takes hours. Run fiddy node logs to watch progress, then keep waiting; fiddy node status works after the load completes.

If your disk filled up

The first boot briefly needs about 2 TB, with a measured peak of about 1.66 TB. A smaller disk fills and the whole download starts over from chunk 1. Free up space or move to a computer with 2 TB free, then run it again. Do not retry on the same full disk.

If your laptop went to sleep

Your computer paused, so a local download paused with it. Keep it plugged in and awake, or move to a computer that stays on (about $120-285/month to rent one).

Snapchain or Hypersnap. Pick deliberately.

Snapchain is Farcaster’s own network, where every account, cast, and follow lives. Pick this. Hypersnap is an independent parallel network built by the Quilibrium community: the same kind of social data, different plumbing and economics. It is for explorers, not where your Farcaster account lives.

fiddy node up --network snapchain    # Farcaster's own network, the default
fiddy client up --network hypersnap  # read the public Hypersnap node

Reading Hypersnap needs no server at all. It reads the public Hypersnap node at haatz.quilibrium.com, which answers today. Nothing to install, nothing of yours runs.

Running your own Hypersnap node is the part that is not ready. The software is real and installable, but the copy it installs keeps an out-of-date list of who is allowed to decide blocks. It stops following the network after a while while still reporting itself healthy. The fix today is to take that list from Snapchain’s own repository, and upstream’s issue is still open. So fiddy node up --network hypersnap prints exactly what is known and stops rather than installing something that will quietly fall behind.

Which network is Fiddy reading? It says so.

A node does not announce which network it is. The same status page comes back on both, so the client never guesses. It shows the network in Advanced → your node, where you can switch between the networks you can actually read: the public Hypersnap node and your own node when you run one. A network with nothing behind it is listed with the reason, never as a button that fails after you press it.

3Client

Open Fiddy on your node.

fiddy client up boots the web client pointed at your node for reads and writes. If your node’s API is locked to your IP, the AWS default, add --tunnel and the CLI opens an SSH tunnel for the session. Nothing to install first: the CLI brings Docker, Node 22, and pnpm itself when they are missing.

fiddy client up --tunnel

Signing in is a QR code and your phone. Press Sign in, or just write a cast. The client shows a code, you scan it with the Farcaster app and approve there, and your own node confirms which account signed. The client ends up with its own ed25519 app key, registered by a gasless KEY_ADD message. No Optimism transaction, no ETH, confirmed in seconds. Your custody key and recovery phrase are never asked for. The app key signs your casts, follows, and reactions: scoped, capped, and revocable from the UI with a KEY_REMOVE.

It works as it is: Fiddy’s own signer asks for the key, and the approval is the same. To have your instance ask instead, export FIDDY_INSTANCE_APP_FID and FIDDY_INSTANCE_APP_KEY, a spare account of yours, before fiddy client up. Either way it costs you nothing, and either way you can still add a key by hand from Advanced, where the recovery-phrase path lives for test accounts and developers. Details: docs/CLIENT-SELF-HOSTED-CONNECT.md.

Seed phrases: powerful, handle like rm -rf

A seed phrase is your custody address is your FID. Anyone holding it owns the account. Follow this tutorial with a test account only. In general, paste a seed phrase only into software from developers you trust, running locally, with source available. This repo is MIT and the phrase never leaves your browser, but verify that yourself. That is the point of open source. Wherever possible prefer delegated signer authorization, approving an app key from an already-authenticated client, over seed import.

From here the client is fully yours: read the feed from your node, post casts, follow, react, and include or exclude casts from any other client in your view settings.

Identity lives onchain. Social data lives offchain. Your node joins the two.

How Farcaster fits together

Farcaster is hybrid. Identity lives onchain on OP Mainnet, data lives offchain. Onchain is used only when security and consistency are critical: creating an account, paying storage rent, registering keys. Everything social, including casts, follows, reactions, and profile pictures, is an offchain message signed by a key the chain knows about.

FID
Your account number, minted onchain to your custody address. Everything you do offchain references it.
Custody address
The Ethereum key that owns your FID. The master key. It authorizes everything else and touches nothing day to day.
App key, or signer
An ed25519 key a client uses to sign messages for your FID. Authorized by your custody address. Revocable. This is what “log in to a client” means under the hood.
Snapchain
The peer-to-peer network storing all user data, Farcaster’s own. Validators propose blocks. Read nodes follow, store, and serve APIs. Hypersnap is a separate network with the same idea. See Snapchain or Hypersnap.
Storage rent
A small onchain payment that buys your FID the right to store data. No rent, no writes. Your account already has storage if you have used Farcaster.
Your client, with an agent inside

Meet your Fiddy agent.

One click in the client provisions a dedicated Hermes instance on Agent37 cloud. Not a chatbot, a real agent with its own computer, awake 24/7. It lives in your client, chats with you there, and runs scheduled jobs: “check my mentions every morning,” “draft my weekly recap cast.”

Through Hermes, your Fiddy reaches every channel you do, with your explicit approval on each one.

  • Farcaster
  • iMessage
  • Discord
  • Telegram
  • WhatsApp
  • Email
  • Web & API

Your agent acts on Farcaster under its own FID and its own gasless app key, clearly the agent’s voice, revocable by you at any time. It reads from the same node you just stood up: the whole stack, end to end, with nobody’s API key in sight.

Questions you’ll hit.

Does this cost ETH?

No. App keys are gasless KEY_ADD messages since Snapchain V16. You need an existing account with storage rent paid. That is all.

Can my node accept casts?

Yes. Read nodes validate and gossip writes to validators. They hold no mempool, so under load a write can drop. Watch for MERGE_MESSAGE or query it back, and resubmit if needed.

What can the app key do?

Only the message types you scope it to: casts, reactions, links, user data. Keys slide-expire in at most 90 days, cap at 1000 per FID, and revoke instantly with KEY_REMOVE.

Where’s the custody key?

In your browser, used once for the EIP-712 KEY_ADD authorization, then idle. Never sent anywhere, never stored server-side.

Who am I depending on?

Your compute provider for uptime, and the Snapchain validator set for block production, the same set every client depends on. Reads, writes, and identity tooling are all yours.