Quickstart
Start with the Artax setup that fits your launch.
This quickstart walks through dashboard setup, devnet-first testing, hosted review, direct API and SDK use, funding, and adding a separate mainnet-beta key when you are ready for live traffic.
Choose your first path
Start with the smallest surface that fits your product. Bootstrap the account from the dashboard, use hosted review for the lightest integration, then move into direct API and SDK usage when you need tighter control. Devnet is the test path, and mainnet-beta key creation is a separate additive step.
1. Dashboard-backed bootstrap
Open Start Here, create the account, complete verification if needed, inspect the default project and sandbox key, and keep the first launch on devnet.
2. Hosted review launch
Send a prefilled reviewed intent into the Artax review workspace and let the user keep signing in their existing wallet path while you validate the integration on devnet.
3. Direct API and SDK usage
Move into typed client helpers, embedded review UI, account reads, and the separate execution-request path only when the integration truly needs more than a redirect launch.
4. Mainnet-beta key
When sandbox validation is stable, create a separate mainnet-beta key for the same project, then fund the paid path without collapsing your devnet test environment.
Launch checklist
Follow this sequence
- Create an account from the dashboard or by calling POST /api/accounts.
- If verification is required, request a fresh verification link with POST /api/accounts/request-email-verification and complete the step through /verify-email or POST /api/accounts/verify-email.
- Use the default project and sandbox key to inspect GET /api/account/overview, GET /api/projects, and GET /api/api-keys, and keep the first integration on devnet.
- Choose hosted review first when you want the lightest current integration path, then validate your own app against devnet before asking for mainnet-beta usage.
- Use the typed SDK and direct API helpers when you need a tighter product integration, embedded review setup, or bounded transfer sponsorship, but still keep the first real traffic in sandbox scope.
- Devnet stays included and rate-limited. It is the place to rehearse your product, your agents, and your release process before paid traffic exists.
- When you are ready for live traffic, create a separate mainnet-beta API key under the same project instead of silently flipping the devnet key.
- Add prepaid USDC through the Add Funds flow when you need expanded paid usage on mainnet-beta, then issue a funded-advisory key through the explicit upgrade route.
- If you intentionally need sponsored review requests, use the separate execution-request key path instead of widening the default sandbox or funded-advisory key.
What this page covers
This page is a launch guide, not a full API contract or universal compatibility statement. Use it to find the setup flow quickly.
Hosted review launch
Start here when you want the lightest production-shaped integration.
/review?mode=transfer&source=PartnerApp&recipient=<wallet>&tokenMint=<mint>&amount=12.5SDK starter
Move to typed helpers when you need direct API access or reusable Artax review components inside your own product.
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
};
}
return {
analysisId: analysis.analysisId,
preparedTransactionBase64: analysis.preparedTransactionBase64,
sponsorshipApproved: decision.sponsorshipApproved
};
}Migration guide
Use the dedicated devnet-to-mainnet-beta cutover guide when you are ready to keep testing while preparing the live path.
API docs
Use the Developers page as the current API, SDK, and embedded review reference hub.
AI-agent onboarding
Use the dedicated AI-agent onboarding wizard for the current bootstrap sequence and authority boundaries.
Funding guidance
Open the USDC funding path, funding stage explanation, and current deposit instructions.
Token support
See how curated token profiles differ from the broader fail-closed SPL transfer rail before you hard-code token assumptions.
Project inventory
Use project inventory to keep devnet and mainnet-beta work organized instead of retargeting a single project between clusters.
Free tier and pricing
Inspect the generous free-tier posture, usage-only pricing, no-monthly-fee rule, devnet included posture, and prepaid USDC upgrade path for mainnet-beta usage.
Keep devnet alive
- Devnet is not a throwaway prelaunch hack. It is the long-lived Artax sandbox path for builders, partner QA, and post-launch regression work.
- Your first project can stay devnet-focused forever if your product or your partners still need ongoing Solana devnet support.
- Mainnet-beta setup should feel additive: keep the devnet key and create a new mainnet-beta key for the same project when launch validation is complete.
- Only mainnet-beta usage should reduce prepaid USDC balance. Devnet stays included and rate-limited so teams can keep testing responsibly.
Promote into mainnet-beta cleanly
Keep the sandbox project
Do not overwrite the devnet project that already proves your integration. Keep it for ongoing QA, regression tests, and partner certification.
Create the live project
Provision a separate mainnet-beta key when the product path is ready for live traffic and scoped commercial use.
Issue a separate live key
Create a new mainnet-beta key with the exact scopes needed for launch instead of reusing the sandbox credential.
Fund only the live path
Add prepaid USDC when the mainnet-beta project is the one preparing for real traffic, while devnet remains the free sandbox.
Keep these caveats attached
- Hosted review is the easiest current launch path, but it is not proof of full embedded signing ownership.
- The current quickstart combines dashboard bootstrap, hosted review, and typed API or SDK usage rather than claiming a broader docs backend or compatibility matrix.
- The published supportedTokens list is a curated token-profile surface rather than the entire transfer boundary, and sponsorship still fails closed when token mechanics, route confidence, or economics are weak.
- AI-agent onboarding is API-first, while execution requests stay on a separate approval path and broader autonomous authority remains outside the default path.
- Funding stays USDC-prepaid. There is no unsecured SOL funding path.
Next surfaces
Where to go after first launch
Account reads
Use account overview, projects, API-key inventory, usage, and funding status once the account is bootstrapped.
Project and key management
Create narrower devnet and mainnet-beta projects, rename them, and issue narrower keys for specific agents.
Funded advisory upgrade
Stay free-tier first, then retrieve the current USDC funding instructions only when you truly need expanded paid usage on mainnet-beta and issue a dedicated funded-advisory key after credited balance lands.
Human-approved execution request
When a reviewed sponsorship path is truly needed, issue a separate execution-request key rather than widening the default sandbox or funded-advisory posture.