Kobaru

​

Kobaru Products

• Kobaru Console: A central revenue command center that allows users to manage payment infrastructure, track real-time analytics, and perform professional financial reconciliation without writing code.
• Transparent Proxy: A no-code monetization tool that transforms any existing API into a paid endpoint by wrapping it in a payment layer without requiring changes to the original backend.
• Kobaru Gateway: The core facilitator infrastructure that handles cryptographic signatures and verifies instant settlements on the SKALE network for incoming payment requests.
• API Paywall Cookbook: An open-source repository of production-ready templates and examples that help developers implement various monetization patterns across multiple programming languages.

​

Why SKALE Base with Kobaru?

​

Prerequisites

• A EVM wallet address - to receive USDC payments
• An API you want to monetize
• Basic understanding of x402 protocol. To learn more about it check here.

​

Instant API Monetization

​

Step 1: Create Your Kobaru Account

1. Go to console.kobaru.io
2. Sign up with your email

​

Step 2: Register Your API

1. Click New Service
2. Configure your service:
   • Service name: Descriptive name (e.g., skale-data-api)
   • Backend URL: Your API’s base URL (e.g., https://api.yourcompany.com)
   • Slug: Unique identifier for proxy URL (e.g., skale-data)
3. Define your first paid route:
   • Route pattern: Endpoint path (e.g., /premium-data)
   • Price: Cost per request in USD (e.g., $0.001)
   • Network: Select SKALE Base (Mainnet or Sepolia)
   • Usage model: pay_per_request or pay_per_time

​

Step 3: Go Live and Get Paid

https://access.kobaru.io/{your-slug}/premium-data

• Returns an HTTP 402 response with payment requirements on unpaid requests
• Verifies payments on SKALE Base with cryptographic proof
• Forwards authenticated requests to your backend
• Settles payments to your wallet in ~1 second
• Logs every transaction for reconciliation

​

x402 SDK

​

Official support

• TypeScript/Node.js - Full middleware support for Hono and Express
• Go - Integration for Go backends with Gin
• Python - Flask and FastAPI compatibility

​

Integration

# Required: Your wallet to receive payments
WALLET_ADDRESS=0xYourWalletAddress

# Optional: Kobaru API key for enhanced features
KOBARU_API_KEY=your_api_key_from_console

import { Hono } from "hono";
import { serve } from "@hono/node-server";
import { cors } from "hono/cors";
import { paymentMiddleware, x402ResourceServer } from "@x402/hono";
import { ExactEvmScheme } from "@x402/evm/exact/server";
import { HTTPFacilitatorClient } from "@x402/core/server";
import "dotenv/config";

const app = new Hono();
app.use("*", cors());

async function main() {
  // Configure Kobaru facilitator
  const facilitatorUrl = "https://gateway.kobaru.io";
  const facilitatorClient = new HTTPFacilitatorClient({
    url: facilitatorUrl
        })
  

  // Register EVM payment scheme for SKALE
  const resourceServer = new x402ResourceServer(facilitatorClient);
  resourceServer.register("eip155:*", new ExactEvmScheme());

  // Fetch token metadata from Kobaru instead of hardcoding
  const networkId = "eip155:324705682"; // SKALE Base Mainnet
  const assetAddress = "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD"; // USDC on SKALE Base

  // Define payment requirements
  const routes = {
    "GET /api/data": {
      accepts: [
        {
          scheme: "exact",
          network: networkId,
          payTo: process.env.WALLET_ADDRESS as `0x${string}`,
          price: {
            amount: "1000", // 0.001 USDC
            asset: assetAddress,
            extra: { 
              name: "USDC", 
              version: "2" 
              }
          }
        }
      ],
      description: "Premium data access",
      mimeType: "application/json"
    }
  };

  // Apply payment middleware
  app.use("*", paymentMiddleware(routes, resourceServer));

  // Protected endpoint
  app.get("/api/data", (c) => {
    return c.json({
      message: "Premium data unlocked!",
      timestamp: new Date().toISOString()
    });
  });

  const port = 3000;
  serve({ fetch: app.fetch, port }, () => {
    console.log(`Server running on http://localhost:${port}`);
    console.log(`Using Kobaru facilitator: ${facilitatorUrl}`);
  });
}

main().catch(console.error);

import { x402Client, x402HTTPClient } from "@x402/core/client";
import { ExactEvmScheme } from "@x402/evm";
import { privateKeyToAccount } from "viem/accounts";
import "dotenv/config";

async function main() {
  const account = privateKeyToAccount(
    process.env.PRIVATE_KEY as `0x${string}`
  );

  const evmScheme = new ExactEvmScheme(account);
  const coreClient = new x402Client().register("eip155:*", evmScheme);
  const httpClient = new x402HTTPClient(coreClient);

  const url = "http://localhost:3000/api/data";
  const response = await fetch(url);

  if (response.status === 402) {
    console.log("Payment required, processing via Kobaru...");

    const responseBody = await response.json();
    const paymentRequired = httpClient.getPaymentRequiredResponse(
      (name: string) => response.headers.get(name),
      responseBody
    );

    const paymentPayload = await httpClient.createPaymentPayload(
      paymentRequired
    );
    
    const paymentHeaders = httpClient.encodePaymentSignatureHeader(
      paymentPayload
    );

    const paidResponse = await fetch(url, {
      headers: { ...paymentHeaders },
    });

    const data = await paidResponse.json();
    console.log("Data received:", data);
  }
}

main();

​

Kobaru Console

• Real-time analytics - Live transaction feed, revenue tracking, settlement confirmation
• Failure diagnostics - Identify and resolve payment issues before they impact customers
• Professional reconciliation - Complete audit trails and exportable reports for compliance
• Manage your payment infrastructure without touching code - Adjust pricing, endpoints, and rate limits instantly
• Improved performance - Priority routing and enhanced uptime guarantees
• Enterprise support - 24/7 diagnostics with guaranteed response times

const facilitator = new HTTPFacilitatorClient({
  url: "https://gateway.kobaru.io",
  headers: {
    "Authorization": `Bearer ${process.env.KOBARU_API_KEY}`
  }
});

​

Troubleshooting

​

Payment verification fails

​

Viem token metadata issues

// Fetch from Kobaru instead of hardcoding
const supported = await facilitatorClient.getSupported();
const networkData = supported.kinds?.find(
  (kind: any) => kind.network === networkId &&
  kind.extra?.asset?.toLowerCase() === assetAddress.toLowerCase()
  );
if (networkData?.extra) {
	const { name, version, decimals } = networkData.extra;
	return {
		name: (name as string),
		version: (version as string),
		decimals: (decimals as number)
	};
}

​

Next steps

​

Resources

• Kobaru Documentation
• x402 Protocol Specification