Start Here

Getting started

TAG IT Network is live on Base Sepolia testnet (chainId 84532). Every command on this page was run against the live deployment: the contracts are deployed and verified, the subgraph is indexing, and the gateway answers /health. There is no signup, no API key, and no wallet needed for reads — the chain is public.

What you can do today

• Read any asset's lifecycle state straight from TAGITCore with viem or ethers — no credentials required.
• Get free Base Sepolia ETH from a faucet for your own transactions.
• Query the indexed ERC-8004 agent registry through the Goldsky subgraph (GraphQL).
• Call the gateway at api.tagit.network — GET /health, and POST /verify, which replies with an x402 payment envelope.
• Inspect the verified contract source on BaseScan.

1. Read asset state with viem

The snippet below reads live state from the TAGITCore proxy on Base Sepolia. It needs Node.js 18+ and one dependency:

npm install viem

Save the following as read-state.mjs and run node read-state.mjs:

// Read live protocol state from Base Sepolia — no wallet or API key needed.
import { createPublicClient, http, parseAbi } from "viem";
import { baseSepolia } from "viem/chains";

// TAGITCore proxy on Base Sepolia (chainId 84532)
const TAGIT_CORE = "0x3aDc7EFDb58Ae85483eFf5D4966D916185f31d1D";

const abi = parseAbi([
  "function totalSupply() view returns (uint256)",
  "function getAsset(uint256 tokenId) view returns (address assetOwner, uint64 timestamp, uint8 state, uint8 flags, uint16 reserved)",
]);

const STATES = [
  "NONE", "MINTED", "BOUND", "ACTIVATED", "CLAIMED", "FLAGGED", "RECYCLED",
];

const client = createPublicClient({ chain: baseSepolia, transport: http() });

const supply = await client.readContract({
  address: TAGIT_CORE,
  abi,
  functionName: "totalSupply",
});
console.log("Digital twins minted:", supply);

const [owner, updatedAt, state] = await client.readContract({
  address: TAGIT_CORE,
  abi,
  functionName: "getAsset",
  args: [1n],
});
console.log("Asset #1 owner:", owner);
console.log("Asset #1 state:", STATES[state]);
console.log("Last state change:", new Date(Number(updatedAt) * 1000).toISOString());

getAsset() returns the packed asset record — owner, last state-change timestamp, and the lifecycle state as a uint8:

See Asset Lifecycle for the full transition rules — including flag() from BOUND, ACTIVATED, or CLAIMED, and resolve() returning an asset to its exact pre-flag state.

2. Get Base Sepolia testnet ETH

Reads are free — you only need testnet ETH to send transactions of your own. Any Base Sepolia faucet works:

• Alchemy Base Sepolia faucet
• Coinbase Developer Platform faucet
• Full faucet list in the Base docs

3. Query the Goldsky subgraph

The ERC-8004 agent registry is indexed on Goldsky and queryable over GraphQL — agents, their status changes, reputation feedback, and validation requests and responses:

curl -s https://api.goldsky.com/api/public/project_cmk3631vfave701vphm5ted0l/subgraphs/tagit-indexer/0.2.0/gn \
  -H "Content-Type: application/json" \
  -d '{"query": "{ agents(first: 5) { agentId statusLabel averageRating feedbackCount isValidated } }"}'

The deployed query root is exactly protocol, agent, agentMetadata, agentStatusChange, feedback, validationRequest and validationResponse (each with its plural collection). Escrow, staking, treasury and asset-lifecycle entities are defined in the repository but are not deployed at this endpoint — indexing them is planned, not yet available. The full schema lives in the tagit-indexer repository.

4. Call the gateway

Without a key, api.tagit.network gives you four things: GET /health (status plus per-agent health), GET /.well-known/agent.json (the A2A agent card), GET /api/v1/agents (the agent directory) and POST /verify, which replies with an x402 payment envelope (HTTP 402) stating what the call costs before it will run.

# Gateway health — returns JSON, no key required
curl -s https://api.tagit.network/health

Everything else on that host — POST /api/v1/agents/:agentId/invoke, POST /mcp, POST /a2a and any unlisted path — answers 401 until you send an API key (probed 2026-10-23). For keyless tool calls use the read-only MCP server at verify.tagit.network/mcp, documented on the Agent API page. Agent identity, reputation and validation are always readable from the contracts or the subgraph above.

Physical verification happens on tap, not over this API. An NFC tag encoded by TAG IT resolves to verify.tagit.network carrying the picc and cmac parameters the chip generates, and the response includes a W3C Verifiable Credential digital product passport. Those URLs cannot be constructed by hand — the chip has to produce them.

The x402 payment flow is documented in the Agent API section.

5. Explore contracts on BaseScan

All deployed contracts are verified — you can read source, inspect state, and call view functions directly in the browser:

• TAGITCore on BaseScan — 0x3aDc7EFDb58Ae85483eFf5D4966D916185f31d1D
• The full address table (access control, badges, token, governance, recovery, paymaster) is on the Contract Addresses page.

What's coming

All items below are planned, not yet available:

• Dashboard onboarding — a guided flow in the admin console for minting and binding test assets without writing code.
• ORACULAR mobile app — consumer scan-and-verify for NFC-tagged products.
• External audit — engagement with Hacken is scheduled; no external audit has been performed yet, and no audit report exists. What does exist is internal static analysis: a Slither baseline dated 2026-02-20 with 4 HIGH findings, all reviewed and accepted as by-design, access-controlled ETH transfers.
• Mainnet — audit-gated, targeted H1 2027; a public bug bounty launches alongside it. Security contact: info@tagit.network.