Choose an Artax integration path that fits your product.

Account operations

• Create an account, request a fresh verification link when needed, complete verification, then inspect account, project, API key, balance, funding status, usage, funding instructions, and restrictions.
• Create projects, create scoped API keys, revoke keys, and review project or API-key holds from the dashboard and API.
• Use current advisory review access inside sandbox limits instead of jumping directly to funded or autonomous execution.
• Retrieve prepaid USDC funding instructions without turning funding into an unsecured SOL flow.

Authority and approval boundary

Agent-ready HTTP

One direct review call

This is the smallest current integration path for coding agents and server apps: request bounded transfer sponsorship when needed, read the server decision, and only continue when the response allows it.

export async function reviewWithArtaxFetch() {
  const apiBaseUrl = process.env.ARTAX_API_BASE_URL;
  if (!apiBaseUrl) {
    throw new Error("ARTAX_API_BASE_URL is required.");
  }

  const headers = {
    "content-type": "application/json",
    ...(process.env.ARTAX_APP_KEY ? { "x-artax-app-key": process.env.ARTAX_APP_KEY } : {}),
    ...(process.env.ARTAX_ACCOUNT_API_KEY
      ? { "x-artax-api-key": process.env.ARTAX_ACCOUNT_API_KEY }
      : {})
  };

  const response = await fetch(`${apiBaseUrl}/api/analyze-transfer`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      appId: "your-artax-app",
      walletAddress: "USER_WALLET",
      recipientAddress: "RECIPIENT_WALLET",
      tokenMint: "TOKEN_MINT",
      amount: "12.5",
      sponsorshipRequested: true,
      feeHandlingMode: "charge_separately"
    })
  });

  const review = await response.json();

  if (!response.ok) {
    throw new Error(review.requestId ? `${review.error} [${review.requestId}]` : review.error);
  }

  if (review.policyAction === "block" || (review.requestedSponsorship && !review.sponsorshipApproved)) {
    return {
      status: review.policyAction === "block" ? "blocked" : "sponsorship_unavailable",
      summary: review.explanationBundle.oneLineSummary,
      warnings: review.warnings,
      sponsorshipReason: review.sponsorshipReason
    };
  }

  return {
    status: "reviewed",
    analysisId: review.analysisId,
    safety: review.userSafety.classification,
    sponsorshipApproved: review.sponsorshipApproved,
    prepaidBilling: review.accountCommercialUsage?.billingMode ?? "included"
  };
}

Agent handling rules

Funding and pricing

• Free sandbox use comes first, then prepaid USDC funding becomes the paid upgrade path.
• Devnet sandbox usage stays included and rate-limited, while mainnet-beta usage is the path that reduces shared prepaid USDC balance.
• Public pricing stays simple: no monthly fee, usage-only charges, prepaid USDC balances for paid API usage, and a generous free tier before funding is needed.
• The published supportedTokens list is a curated token-profile set, not the full transfer coverage list; broader SPL review can still analyze unfamiliar mints and return a conservative result when confidence is low.
• Funding instructions, funding status reads, and funded-advisory key issuance are available.
• No unsecured SOL funding path is part of the intended model.

SDK starter

The developer layer includes `@artax/sdk`, `@artax/sdk/react`, and `@artax/ui`. Together they cover typed API access, sponsored-transfer review and submit helpers, React hooks for live analysis, browser launch helpers that prefer the add-on and fall back to hosted review, and reusable review modules for embedded flows.

import { ArtaxClient } from "@artax/sdk";

export async function reviewSponsoredTransfer() {
  const client = new ArtaxClient({
    apiBaseUrl: "https://your-artax-api.example.com",
    developerApiKey: process.env.ARTAX_APP_KEY,
    accountApiKey: process.env.ARTAX_ACCOUNT_API_KEY
  });

  const { analysis, decision } = await client.reviewSponsoredTransfer({
    appId: "your-artax-app",
    walletAddress: "USER_WALLET",
    recipientAddress: "RECIPIENT_WALLET",
    tokenMint: "TOKEN_MINT",
    amount: "12.5",
    feeHandlingMode: "charge_separately"
  });

  if (!decision.canContinueToSigning) {
    return {
      status: decision.nextAction,
      summary: decision.summary,
      warnings: decision.warnings,
      sponsorshipReason: decision.sponsorshipReason
    };
  }

  return {
    analysisId: analysis.analysisId,
    preparedTransactionBase64: analysis.preparedTransactionBase64,
    sponsorshipApproved: decision.sponsorshipApproved,
    feeHandlingMode: decision.selectedFeeHandlingMode
  };
}

Keep devnet for testing

• Devnet is the builder sandbox and remains the sandbox after launch, so teams can keep testing integrations and regressions without touching paid mainnet-beta traffic.
• Mainnet-beta setup is a create-new-key step, not a silent retarget: keep the devnet key and issue a separate mainnet-beta key for the same project when you are ready for live users.
• Commercial balance can stay shared at the account level, but devnet stays included and mainnet-beta is the paid path.
• Teams shipping on Solana devnet can keep Artax in their devnet stack all the way through their own launch validation cycles instead of throwing the sandbox away.

Promotion checklist