How to build an app on FLOP compute: a step-by-step devnet guide

Short answer: To build on Flop Network today, you build against the public devnet. You list models at https://api.flop.network/v1, call them with the @flop-labs/client npm package, and move to paid on-chain sessions with @flop-labs/sdk or the flop CLI when your app needs them. Devnet work earns no airdrop credit and nothing carries over, so the reason to start now is to have a working app when the public testnet opens, which Flop targets for November 24, 2026, "subject to readiness".

Last updated November 14, 2026. Package versions and commands are quoted from Flop's SDK and package references (updated November 11) and direct session guide. We ran no paid sessions for this guide.

Key facts

Fact	Value on November 14, 2026	Source
Network you can build on	Public devnet, status "development"	Devnet status
Public testnet	Status "planned", target November 24, 2026, "subject to readiness"	Timeline FAQ
Airdrop credit from devnet	None. "Devnet grants and spend earn no airdrop credit"	Agent onboarding FAQ
Gateway base URL	https://api.flop.network/v1 (OpenAI-style)	SDK references
Models listed on the gateway	2: qwen/qwen2.5-0.5b-instruct and qwen/qwen3-14b	Model list
App client	@flop-labs/client 0.2.2, Node.js 22 or later	SDK references
Chain SDKs	@flop-labs/sdk 0.5.2 (TypeScript), flop-sdk 0.3.0 (Python 3.10+)	SDK references
CLI	@flop-labs/cli 0.4.4	SDK references
Hosted MCP server	https://mcp.flop.network/mcp, read-only	SDK references
Smart contracts	None. FLOP has "no smart contracts and no general-purpose VM"	Technology FAQ

What does "building on FLOP" mean?

FLOP is a payments and settlement chain for AI inference. Agents pay miners in FLOP to run open-weight models, and validators record proof that the work was done. There is nothing to deploy: Flop's technology FAQ says builders "work with the protocol's own primitives (inference requests, HTLC escrow and swaps, memory, identity) through interfaces, indexers and connectors rather than by deploying contracts." A team that needs smart contracts should "build that part on an EVM chain and settle compute on FLOP."

So an app on FLOP compute is any program that buys inference from the network: a chat feature, an agent, a coding assistant or a broker that resells compute. The steps below take the simplest route first.

Step 1: Choose how your app will reach FLOP compute

Flop's docs describe two routes on the devnet: the public gateway, which speaks an OpenAI-style API and needs an API key, and a direct session with a named miner, which your own wallet opens, verifies and settles on chain.

Route	Package	Use it when
Public gateway	@flop-labs/client	You want chat completions from an app with the least setup
Response checks	@flop-labs/contracts	You want to validate gateway payloads in your own client
Direct miner session	@flop-labs/sdk, flop CLI or local MCP	Your app pays a specific miner and verifies receipts itself
Python chain work	flop-sdk	Your backend is Python and needs agent wallets or signed transactions
Pi coding agent	@flop-labs/pi	You want FLOP models inside the Pi coding agent

Start with the gateway unless you need on-chain settlement. Our FLOP SDK guide covers each package in more depth.

Step 2: Create a test wallet and fund it from the faucet

The devnet faucet pays test FLOP to an address in SS58 format and suggests the Polkadot.js, Talisman and SubWallet extensions, which "support FLOP with SS58 prefix 42". Use a fresh address that holds nothing of value.

The faucet offers a quick fund of 25 FLOP "for dev testing" and a verified-human grant of 500 to 2,000 FLOP. The agent onboarding FAQ gives the devnet limits for the Self and BrightID tier: "a 500-FLOP base grant, up to 2,000 FLOP per grant, a 2,000-FLOP rolling seven-day cap and a 24-hour cooldown." Final testnet faucet limits "have not been announced."

Before funding, the direct session guide says to compare the public RPC (wss://rpc.devnet.flop.network) genesis with https://faucet.flop.network/chain. It also warns that "a 503 from /fund is a refused or unconfirmed request, not a reason to create another wallet." Keep one wallet and retry. Test FLOP has no value.

Step 3: List the models on the gateway

Model discovery needs no key, so this is the first call to make. The docs' contracts example fetches the list and validates it:

npm install @flop-labs/contracts

import { assertModelList } from "@flop-labs/contracts";
const value: unknown = await fetch("https://api.flop.network/v1/models").then((r) => r.json());
assertModelList(value);

On November 14 the model list held two text-to-text models: "Qwen2.5 0.5B Instruct (devnet-ts)" with a 32,768-token context, and "Qwen3 14B (FLOP devnet)" with an 8,192-token context and a 512-token completion limit. Flop warns that "a gateway model catalog is discovery data and is not proof that inference is available," so handle errors on the first real call.

Step 4: Get a gateway allowance

Chat completions need an API key, and on the devnet that key comes with an allowance issued through wallet enrollment. The agent integration guide says "the public wallet lane requires an explicitly configured operator quota; there is no default grant amount."

Once enrolled, read the authenticated GET /v1/keys/me response. Its remaining_quota is "the remaining spend allowance in FLOP, not tokens", and expires_at is in epoch milliseconds. "The public wallet lifetime is at most 24 hours." Three details from the docs save debugging time:

• Faucet funds and gateway allowance are separate. "A gateway allowance spends the gateway broker's funds and does not add FLOP to your wallet."
• New wallet issuance has "a shared rolling 24-hour enrollment cap, not a UTC midnight reset." The error wallet_enrollment_cap_reached means the cap is full; wallet_enrollment_unavailable "indicates a service failure."
• Re-enrollment rotates the key but "cannot restore an expired, exhausted or revoked allowance."

Flop's public pages don't document the enrollment request itself, and an open GitHub issue asks Flop for the issuance procedure. Nobody legitimate sells FLOP API keys. Keep the key in an environment variable and never paste it into a public issue.

Step 5: Call a model with @flop-labs/client

The client is a small ESM Fetch client for browsers and Node.js 22 or later. This is the example from Flop's docs:

npm install @flop-labs/client

import { FlopClient } from "@flop-labs/client";
const client = new FlopClient({ apiKey: process.env.FLOP_API_KEY });
const models = await client.listModels();
const completion = await client.createChatCompletion({
  model: models.data[0].id,
  messages: [{ role: "user", content: "Hello" }],
});

The client also has getModel and streaming chat completions, and its errors surface as FlopHTTPError. The package README covers "caller-owned replay identity, recovering an ambiguous request, and task correlation", which matters if your app retries calls. Our gateway apps guide shows where this fits in a chat product.

Step 6: Open a direct session with a named miner

A direct session is the on-chain route: your wallet escrows FLOP, a named miner serves the request, and the SDK checks every receipt before paying. Flop's direct session guide gives this CLI command for the devnet:

flop --network devnet --keystore agent.json --password-env FLOP_KEY_PASSWORD session run \
  --miner '<miner-ss58>' --model qwen/qwen2.5-0.5b-instruct \
  --prompt 'Say hello.' --max-flop 0.01 --via auto \
  --endpoint http://127.0.0.1:8645 --json

--max-flop is "the escrow ceiling in FLOP", and transaction fees are extra. The same flow in TypeScript uses runDirectSession from @flop-labs/sdk, which "verifies every receipt before accepting output or signing payment." The guide's prerequisites are strict: you need the miner's SS58 account and a reachable session endpoint, either on the miner host or a miner's "opted-in public HTTPS endpoint". Public agents without one "need the gateway's separate miner-pin path." Expect this step to fail until you have a qualified miner to call.

Step 7: Put limits on what the app can spend

Give the app a bounded key, never your main wallet. Flop's technology FAQ says "a session or agent key is derived from the main wallet with a spending limit and an expiry." The TypeScript SDK exposes this through createAgentWallet, fundAgentWallet, agentTransfer, ownerWithdraw, createSession and executeViaSession. For the Pi package, Flop advises "a bounded child credential with a spend cap rather than an owner key." Our agent budgets guide explains the on-chain controls.

Step 8: Keep the network configurable

An app that hard-codes devnet endpoints will need a code change on testnet day. The CLI takes --network <name> to target a network, and the testnet status page says a network isn't ready until "its expected genesis, chain spec, bootnodes, public RPC/gateway, supported release, and admission authority are published and verified." Read RPC, faucet and gateway URLs from config so you can switch when Flop publishes the testnet values. Pin SDK and CLI versions and follow Flop's upgrade guide when they change.

Step 9: Be ready to spend on testnet day one

When the testnet opens, the timeline FAQ lists the minimum for an agent: "an identity key (the same DID key used on TechnoCore), the ability to make HTTP requests, and the ability to call the testnet faucet and submit an inference request signed with that key." The draft testnet page says onboarding documentation for each role "is published when the testnet opens." What your app earns there is covered in our guide to the FLOP testnet airdrop for developers.

What Flop hasn't documented yet

Gap	What the docs say on November 14, 2026
Testnet endpoints	Not published. Testnet status is "planned"
Testnet faucet limits	"Final Testnet faucet limits have not been announced"
Gateway enrollment request	Described, but the request format isn't on Flop's public pages
Launch time on November 24	Not published. Flop Labs called the date "tentative"
Paid HTLC chat route	flop chat "uses HTLCs, which require a registered EconomicCritical appraisal profile"; the devnet registry was empty on November 3
Builder rewards	No grant or builder allocation, per the technology FAQ. See the developer airdrop guide

Avoid FLOP builder scams

There is no FLOP token yet, and test FLOP is worthless. Flop's SDK page says no package "sells or claims" a token, and that a Rust crate, Go module or "x402 types or Hermes plugin" package claiming to be FLOP's "is not FLOP's." Never type a seed phrase into a site, a faucet or an AI agent, and ignore any "FLOP airdrop checker" that asks you to connect a wallet with funds. Check links against our official links list and our scam warnings.

Next guides

Building an agent rather than an app? Read how to build an AI agent that pays for inference on FLOP. For the airdrop rules that apply to apps, read the FLOP testnet airdrop for developers. The devnet builder quickstart and the testnet hub track changes.

FAQ

How do I build on Flop Network?

Build against the public devnet. List models at api.flop.network/v1, call them with the @flop-labs/client package using an API key, and use @flop-labs/sdk or the flop CLI for direct, on-chain sessions with a named miner. FLOP has no smart contracts, so you build interfaces, agents and connectors around its inference sessions.

Does building on the FLOP devnet earn the airdrop?

No. Flop's agent onboarding FAQ says devnet grants and spend earn no airdrop credit, and Flop Labs said no devnet state migrates to the testnet. The draft rules credit agents for compute purchased in settled testnet sessions after the testnet opens.

When does the FLOP testnet open for builders?

Flop's docs target November 24, 2026, subject to readiness, and Flop Labs called the date tentative on X. As of November 14, 2026 the testnet status page still read "planned" and no testnet endpoints were published.

Which models can a FLOP app call?

On November 14, 2026 the public gateway listed two text models: Qwen2.5 0.5B Instruct and Qwen3 14B, both labelled as devnet models. The list can change, and a listed model is not proof that a miner is serving it.

Do I need an API key to use FLOP compute?

You need one for chat completions but not to list models. On the devnet the key comes with a gateway allowance issued through wallet enrollment, with a lifetime of at most 24 hours. Flop has not published a public sign-up page for keys, so treat any site selling them as a scam.

Can I deploy a smart contract on FLOP?

No. Flop's technology FAQ says the chain has no smart contracts and no general-purpose VM. Teams that need contracts should build that part on an EVM chain and settle compute on FLOP.