For Developers

Build with Rialink Identity

One API call to verify a wallet across GitHub, Discord, and Farcaster. On-chain receipts on Rialo. No API key required.

FreeNo API KeyRialo Native

Integration Paths

Three ways to integrate, from simplest to most powerful.

REST API

Hit GET /api/verify/:wallet from any runtime. Zero setup.

cURL

curl https://rialink.vercel.app/api/verify/WALLET_ADDRESS

npm SDK

Typed helpers for verify, policy checks, and proof management. Works in Node, Deno, and edge runtimes.

JavaScriptnpm install @rialink/sdk

import { Rialink } from "@rialink/sdk";

const rialink = new Rialink("https://rialink.vercel.app");

// Verify a wallet — returns identity + trust level
const identity = await rialink.verify("BqKJkx...f3Ht");

if (identity.trustLevel === "high") {
  // 3 platforms verified — grant access
}

// Check policy requirements
const result = await rialink.checkPolicy("BqKJkx...f3Ht", {
  platforms: ["github", "discord"],
  minPlatforms: 2,
  minRepoCount: 5,
});

if (result.passed) {
  // wallet meets requirements
}

React Hooks + Components

Drop-in useRialink() hook and <RialinkBadge /> component.

React@rialink/react

import { useRialink, RialinkBadge } from "@rialink/react";

function MyComponent({ wallet }) {
  const { identity, isLoading } = useRialink(wallet);

  if (isLoading) return <Spinner />;
  if (!identity?.valid) return <span>Not verified</span>;

  return (
    <div>
      <RialinkBadge wallet={wallet} />
      <p>Trust: {identity.trustLevel}</p>
      <p>Platforms: {identity.proofs.length}/3</p>
    </div>
  );
}

Quick Start

Use the REST API directly from any runtime. Base URL: https://rialink.vercel.app

JavaScript

// Verify a wallet — no auth required
const res = await fetch(
  "https://rialink.vercel.app/api/verify/WALLET_ADDRESS"
);
const identity = await res.json();

if (identity.valid && identity.trustLevel === "high") {
  // wallet is verified on 3 platforms
}

Python

import requests

r = requests.get(
    "https://rialink.vercel.app/api/verify/WALLET_ADDRESS"
)
identity = r.json()

if identity["trustLevel"] == "high":
    # grant access

Live API Playground

Test real endpoints with a wallet address and inspect the exact JSON response.

Verify Response

{
  "hint": "Run verify to see response"
}

Policy Check Response

{
  "hint": "Run policy check to see response"
}

Playground Integration

Drop Rialink into any Rialo playground app. Your users carry their verified identity everywhere.

Rialink is identity infrastructure for the Rialo ecosystem. When a user verifies their wallet on Rialink, that verification travels with them to every dApp on Rialo. No re-verification, no re-signing. Your playground app reads the same identity root that Rialink anchors on-chain.

Verify once

User links GitHub, Discord, Farcaster on Rialink

Use everywhere

Every Rialo app reads the same verified identity

On-chain proof

Identity root anchored on Rialo — tamper-evident

Composable

Build trust logic on top of Rialink's identity state

Integration examplelib/access.ts

// In your Rialo app — verify before granting access
import { Rialink } from "@rialink/sdk";

const rialink = new Rialink();

export async function checkAccess(wallet: string) {
  const identity = await rialink.verify(wallet);

  if (!identity.valid) {
    return { allowed: false, reason: "Wallet not verified" };
  }

  if (identity.trustLevel === "none") {
    return { allowed: false, reason: "Verify at least one platform" };
  }

  // Check specific requirements
  const policy = await rialink.checkPolicy(wallet, {
    platforms: ["github"],
    minPlatforms: 1,
  });

  return {
    allowed: policy.passed,
    trustLevel: identity.trustLevel,
    platforms: identity.proofs.map(p => p.platform),
  };
}

On-Chain Receipts (Rialo Anchoring)

Every identity change is anchored on Rialo as a public, tamper-evident memo transaction.

Memo payload format

rialink:v1|<action>|<wallet>|<identityRoot>

action        "create" or "revoke"
wallet        the subject wallet address
identityRoot  64-char lowercase hex sha256

Example:
rialink:v1|create|7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU|3f7a91c0...c9e2

How to verify a receipt independently

1. Open the receipt link: https://devnet.rialoscan.org/tx/<txSignature>
2. Confirm the fee payer / signer is the official Rialink anchor wallet:
   6b96D9tmtkrx2i4nc5tiaLr5pLbne4wenv3iTYe3Bp6r
3. Read instruction #1 memo data (base58) and decode it.
4. Check it matches: rialink:v1|<action>|<wallet>|<identityRoot>
5. Recompute <identityRoot> from GET /api/verify/[wallet] using the recipe
   below. Match => the attested state is publicly guaranteed.

Prefer raw JSON-RPC? POST https://devnet.rialo.io:4101
  {"jsonrpc":"2.0","id":1,"method":"getTransaction",
   "params":[{"signature":"<txSignature>"}]}

Identity root recipe

// Recompute a wallet's identity root from public proof data:
proofHashes = proofs.map(p => p.proofHash).sort()
identityRoot = sha256("rialink:root:v1|" + proofHashes.join("|"))

// proofHash itself is returned by GET /api/verify/[wallet],
// so the whole computation is reproducible without trusting us.

Embeddable Widget

Drop a verification badge into any website with one script tag.

HTMLindex.html

<!-- Drop-in verification badge for any website -->
<div class="rialink-badge" data-wallet="BqKJkx...f3Ht" data-theme="dark"></div>
<script src="https://rialink.vercel.app/embed.js" async></script>

Identity Composability Layer

Other Rialo protocols can read a wallet's Rialink identity. CORS-enabled, no auth required.

GET /api/identity/:walletcomposability

// GET /api/identity/:wallet
// Structured identity for other Rialo protocols
// CORS-enabled — any dApp can read this

const res = await fetch(
  "https://rialink.vercel.app/api/identity/BqKJkx...f3Ht"
);
const identity = await res.json();

// Returns:
// {
//   schema: "rialink.identity.v1",
//   wallet: "BqKJkx...f3Ht",
//   trustLevel: "high",
//   verifiedPlatforms: ["github", "discord", "farcaster"],
//   totalVerified: 3,
//   proofs: [...],
//   identityRoot: "3f7a91c0...",
//   accountAgeDays: 45,
//   reputation: { score: 72, totalSignals: 12, ... }
// }

Wallet-Native Verification

Users verify directly by signing a message with their connected wallet. No OAuth redirects.

3-step flowwallet-native

// Wallet-native verification — no OAuth redirects
// User signs a message, we link their identity

// Step 1: Get challenge
const { nonce, message } = await fetch("/api/challenge/wallet-native", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ wallet: "BqKJkx...f3Ht" }),
}).then(r => r.json());

// Step 2: Sign with connected wallet (Phantom/Solflare)
const { signature } = await wallet.signMessage(
  new TextEncoder().encode(message)
);

// Step 3: Verify and link
const result = await fetch("/api/verify/wallet-native", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ wallet, signature, message, nonce }),
}).then(r => r.json());
// { verified: true, method: "wallet-native", identityLinked: true }

Webhook Notifications

Get notified when verification status changes. HMAC-signed, auto-retrying.

// Webhooks — get notified when verification status changes
// POST /api/webhooks — register a webhook
const webhook = await fetch("/api/webhooks", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    wallet: "BqKJkx...f3Ht",
    url: "https://your-app.com/webhook",
    events: ["proof.created", "proof.revoked", "identity.updated"],
  }),
}).then(r => r.json());
// { id: "wh_...", secret: "whsec_...", url: "...", events: [...] }

// Verify incoming webhooks with HMAC-SHA256:
// Header: X-Rialink-Signature: v1=<hex>,t=<timestamp>
// Use webhook-signing.ts verifyWebhook() to validate

Cross-App Reputation

dApps submit reputation signals, aggregated into a score. Feeds into identity composability.

Submit + read signalsreputation

// Cross-app reputation — dApps submit signals, aggregated into score
// POST /api/identity/:wallet/reputation

await fetch("/api/identity/BqKJkx...f3Ht/reputation", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    source: "my-dapp",           // your dApp identifier
    signal: "trader_active",     // signal type
    value: 0.8,                  // -1 to 1 (negative = bad rep)
    metadata: { tradeCount: 42 },
  }),
});

// GET /api/identity/:wallet/reputation
const rep = await fetch(
  "/api/identity/BqKJkx...f3Ht/reputation"
).then(r => r.json());
// { score: 72, totalSignals: 12, activeSources: [...], topSignals: [...] }

// Reputation is also included in GET /api/identity/:wallet
// when available — no extra call needed.

On-Chain Verifier

Verify trustlessly by reading memo transactions directly from Rialo chain.

SDK methodon-chain

// On-chain verifier — verify trustlessly without calling Rialink API
// Reads memo transactions directly from Rialo chain

import { verifyOnChain } from "@rialink/sdk";

const result = await verifyOnChain("BqKJkx...f3Ht");
// { valid: true, trustLevel: "high", identityRoot: "...", explorerUrl: "..." }

// Or verify the receipt independently:
// 1. Fetch tx from Rialo RPC: getTransaction({ signature: "<txSignature>" })
// 2. Decode instruction #0 data (base58) → UTF-8
// 3. Expect: rialink:v1|create|<wallet>|<identityRoot>
// 4. Recompute identityRoot from GET /api/verify/:wallet proofHashes
// 5. Match = tamper-evident proof

Policy Engine

Define access rules. Rialink evaluates them against a wallet's verified identity.

Request

POST /api/policy/check
Content-Type: application/json

{
  "wallet": "BqKJkx...f3Ht",
  "policy": "dao-grant",
  "requirements": {
    "platforms": ["github", "discord"],
    "minPlatforms": 2,
    "minRepoCount": 5,
    "maxProofAgeDays": 90
  }
}

Response

{
  "wallet": "BqKJkx...f3Ht",
  "policy": "dao-grant",
  "passed": true,
  "trustLevel": "high",
  "evaluatedAt": "2026-08-26T10:00:00Z",
  "checks": [
    { "requirement": "platforms", "required": ["github","discord"], "passed": true },
    { "requirement": "minPlatforms", "required": 2, "actual": 2, "passed": true },
    { "requirement": "minRepoCount", "required": 5, "actual": 47, "passed": true }
  ],
  "accessToken": "vm_[base64-encoded-payload]"
}

Use Cases

DAO Access Control

Gate proposal voting to wallets with 2+ verified platforms. Use policy tokens for gasless on-chain checks.

const policy = await rialink.checkPolicy(wallet, {
  minPlatforms: 2,
  platforms: ['github', 'discord']
});

Airdrop Sybil Resistance

Filter multi-wallet farming by requiring signed identity proofs. Each wallet maps to one real person.

const identity = await rialink.verify(wallet);
if (identity.trustLevel === 'none') reject();

Reputation Portability

Carry your verified identity across Rialo apps. One wallet, one identity, everywhere.

const identity = await rialink.verify(wallet);
// Show same badge across all your apps

Bot Filtering

Reject low-trust or unverifiable wallets before they spam forms, APIs, and airdrops.

if (!identity.valid || identity.trustLevel === 'none') {
  return { error: 'Verification required' };
}

Contributor Badges

Display public proof-backed badges on profiles, dashboards, and contributor pages.

<RialinkBadge wallet={wallet} />

Cross-App Identity

Your Rialink verification works across every Rialo dApp. Build once, trust everywhere.

// Same wallet, same identity, any app
const identity = await rialink.verify(wallet);

API Reference

Method	Path	Auth	Description
GET	/api/verify/[wallet]	None	Public identity + trust level for a wallet
GET	/api/identity/[wallet]	None	Structured identity (rialink.identity.v1 schema) for composability
POST	/api/challenge/wallet-native	None	Issue a challenge for wallet-native verification
POST	/api/verify/wallet-native	None	Verify wallet signature and link identity
GET	/api/identity/[wallet]/reputation	None	Aggregated cross-app reputation score
POST	/api/identity/[wallet]/reputation	None	Submit a reputation signal from a dApp
POST	/api/policy/check	None	Evaluate policy requirements against a wallet
POST	/api/policy/verify	None	Verify a policy access token
GET	/api/proof?wallet=	Wallet signature	List proofs for a wallet (requires wallet proof)
POST	/api/proof	Session + wallet	Save a verified proof (requires session token)
GET	/api/webhooks?wallet=	None	List registered webhooks for a wallet
POST	/api/webhooks	None	Register a webhook (returns shared secret)
DELETE	/api/webhooks?wallet=&id=	None	Delete a webhook registration
GET	/api/health	None	Service health + anchor status
GET	/api/stats	None	Network stats: total wallets, proofs, platforms

Rialo Ecosystem

Rialink is identity infrastructure for Rialo. Every proof is anchored on-chain, every verification is portable across dApps, and every wallet carries its own reputation. Build with it — your users' identity travels with them.