Pixelmine
Network Incentives

Why anyone runs a node.

Pixelmine’s storage is not rented from a data centre — it is contributed by people who choose to run a node. A network like that only holds together if contributing is genuinely worth it, so work is measured, proven, and rewarded. Wherever it can, it rewards work that can be checked, not work that is merely claimed.

Last updated · 13 September 2026

Four ways a node earns

Paid for the work
the network needs.

Each category rewards something the network actually depends on: keeping in sync with other nodes, holding files other nodes can check, staying reachable, and completing syncs successfully. Nothing rewards simply existing.

Syncing with peers

Earned when your node syncs with another node and that node signs a receipt confirming the exchange. At most one counts per peer every ten minutes.

1 point per sync

Storing files

Earned when another node audits yours: it downloads a file you hold and checks its hash. Each distinct file counts once. Your own uploads are recorded, with their size in bytes, but don’t score on their own.

1 point per verified file

Staying online

Earned passively for being reachable. A node checks in roughly every ten minutes, around 144 times a day, from the moment it boots. The network also confirms the node really answers, and counts at most one check-in per ten minutes.

1 point per check-in

Doing it well

Recorded alongside every sync: whether it succeeded and how long it took. Each successful sync adds a point; the timing is shown in the breakdown but doesn’t change the score.

1 point per successful sync
How a score adds up

Four numbers,
one score.

A node’s standing is not a vague reputation anyone argues about. It is the plain sum of four counts, each traceable to events that actually happened: how often you synced, how many of your files were verified, how reliably you were there, and how many syncs succeeded.

  • Every event is worth one point. Syncs count at most once per peer and check-ins at most once per ten-minute window.
  • Storage counts files another node has actually verified, not upload volume. Byte totals are shown for reference but don’t change the score.
  • Quality records each sync’s outcome and how long it took; the score counts the syncs that succeeded.
How a point is awarded

It takes two nodes
to make a point.

The obvious way to cheat a system like this is to claim work you never did. So sync and quality points cannot be claimed alone: the other node in the exchange has to sign a receipt, and the network checks it before anything is recorded.

Node A syncs from Node B Node B signs a receipt Node A reports it with the receipt Both signatures valid? NONo point awarded YES Same node on both sides? YESRejected: no self-credit NO 1 point recorded to Node A
Awarding a point for a sync
Proven, not claimed

Why a node can’t
simply invent its score.

Every protection here exists because someone would otherwise try the shortcut. Together they mean a node’s score reflects work the network can independently confirm.

  • Every report is checked against the key a node registered, so nobody can send a report in another node’s name.
  • Sync and quality points need a receipt signed by the other node in the exchange. A node can’t produce that receipt on its own, because it would need the other node’s key.
  • A node cannot vouch for itself: a report where both sides are the same node is thrown out.
  • Every signed report carries a timestamp that must be recent, and a signature that has already been used is ignored, so an old report can’t be resent for repeat credit.
  • A node that never registered has no key on file, so its reports verify against nothing and are simply refused.
  • Tallies are kept away from the node itself. An operator with full control of their own machine still cannot quietly edit their own score.
Getting counted

How a node starts
earning at all.

Nothing is earned anonymously. Before a node can be credited for anything, the network has to know which key its claims will be checked against.

  • On startup a node introduces itself with its name, description, and public key. That key is what every later report it makes will be measured against.
  • Restarting with the same key does not spawn a second identity: re-introducing itself refreshes the node’s details, and the key on file can’t be swapped out.
  • A node that never registered has no key on file, so its reports verify against nothing and earn nothing at all.
Open to inspection

A score you can look up,
not just take on trust.

Contribution only means something if anyone can check it. So a node’s record is not a private boast — it is readable, itemised, and comparable against every other node.

  • Any node’s full breakdown can be looked up: its sync points, verified storage, check-ins, and how many of its syncs succeeded.
  • Quality goes further than a tally — the breakdown includes the success rate and the average time syncs took.
  • The network’s own totals are open too: how many nodes exist, and what they have contributed between them.
  • A public leaderboard ranks nodes by the sync points they have earned.
Where it’s weaker

What the system
doesn’t claim to solve.

The design is candid about its own edges, which is worth considerably more than pretending they aren’t there.

  • Syncs and quality need a receipt from the other node, so they can’t be produced alone. Check-ins are signed by the node itself — the network confirms the node answers, but otherwise the node is attesting to its own uptime.
  • A receipt proves two nodes took part, not that two different people run them. Nodes operated by the same person can still vouch for each other, and checks against that are still being built.
  • The tally is kept away from the node on purpose, so an operator cannot rewrite their own score. The cost is that scoring leans on that one service — even though the storage network itself does not.
How points are distributed

From work, to points,
to money.

Points travel along a chain. A node earns them for work the network can actually verify, passes a share of them on to the people in its community, and those points can eventually be exchanged for money — which Pixelmine pays out.

STEP 01

The node earns

A node collects points for work the network checks: syncing with peers, holding files other nodes verify, staying reachable, and completing syncs.

STEP 02

The node shares

A share of what it earned goes to the people in its community. That share is recorded for each node by Pixelmine — 60% by default.

STEP 03

Points accumulate

Those points build up against a member’s identity, held as a balance rather than paid out a fraction at a time.

STEP 04

Points become money

Once the balance passes the node’s threshold, points can be exchanged for money — and it is Pixelmine that pays it.

verified work → node earns points → shared with the community → member balance → exchanged for money
  • The share is the pivot of the whole thing: it decides how much of what a node earns stays with the operator carrying the costs, and how much reaches the people in the community. The app shows each community’s share, so members can see what they are working toward.
  • The share is held centrally, not in the node’s own settings, so the percentage on record is the one that is paid — 60% unless Pixelmine sets a different figure for that node. An operator can’t change it from their own machine.
  • Each node sets its own threshold — by default 1% of its community’s points — so exchanges happen in meaningful amounts rather than an endless trickle of tiny payouts.
  • Pixelmine stands behind the exchange itself. An operator never has to fund payouts out of their own pocket — the company converts accumulated points into money.
  • Because the network records what each node earned, and every exchange request is signed by the member making it, the chain from work done to points paid can be checked rather than simply believed.
The revenue split

Following the money
through two splits.

The whole model is really two divisions. Pixelmine puts up a pool to share; it is divided across nodes by the points they earned, and each node’s slice is then split with its community at that node’s share. Here it is with round numbers.

  • First, across the network. Pixelmine decides how much goes into the shared pool. The pool is divided among nodes in proportion to the points each one has earned. A node holding a fifth of the network’s points receives a fifth of the pool.
  • Then, inside the community. The community’s share of the node’s slice — 60% by default — becomes the members’ pool. The rest stays with the operator.
  • Finally, among members. The members’ pool is divided between them according to the points they each earned in that community.
  • Earn more points as a node and your slice of the same revenue grows. Earn the same while the network grows around you, and it shrinks — a share is always relative to everyone else’s.
node’s slice  =  node points ÷ all network points × shared pool
members’ pool  =  node’s slice × the community share

* Only a sample computation — a node’s slice, and what stays with the operator, vary with the points the node earns.

Both panels are a sample computation to illustrate how the split works — not actual figures.

The community’s share

Each node sets
its own threshold.

How much of a node’s slice reaches its community is recorded centrally for each node — 60% by default — and shown in the app. What a node decides for itself is the threshold before its members’ points can be exchanged, and that can differ from one node to the next.

Keeping the share on record centrally means the percentage members see is the percentage that is actually paid.

In short

A network that pays
for what it needs.

Storage, bandwidth, and uptime are real costs. Pixelmine meets them by putting up a pool shared with the people who supply them, passing a share on to the communities they host, and standing behind the exchange at the end — with rewards tied to work other nodes and the network can check.

Next: Democratic System Back to Design & Implementation