​
Subscription Tiers

Agentik Vault offers three subscription tiers with transparent pricing and flexible scaling:
One-time $299 setup fee applies to the first subscription. All plans include a 14-day free trial.

Starter

$49/monthPerfect for building and testing agents
  • 5 agent deployments
  • 100 API calls per minute
  • Email support
  • Basic monitoring
  • All chain access
  • 14-day log retention
  • Standard uptime SLA
  • Core webhooks
  • 2 team members

Pro

$129/month · Most PopularFor professionals and growing teams
  • ✨ AI cost optimization (save 60-65%)
  • 25 agent deployments
  • 1,000 API calls per minute
  • Priority email support
  • Advanced monitoring & analytics
  • All chain access
  • 30-day log retention
  • Custom domains
  • 99.9% uptime SLA
  • Advanced webhooks & automations
  • Team collaboration (10 seats)
  • API access tokens

Team

$349/monthFor large-scale production deployments
  • ✨ AI cost optimization (save 60-65%)
  • 📊 Custom model routing & analytics
  • Unlimited agent deployments
  • 10,000 API calls per minute
  • 24/7 dedicated support
  • Enterprise-grade monitoring
  • All chains + custom networks
  • Unlimited log retention
  • Custom domains + SSL
  • 99.99% uptime SLA
  • Advanced webhooks & automations
  • Unlimited team seats
  • On-premise deployment option
Save 17% with annual billing. Pro & Team tiers include intelligent model tiering to reduce AI costs by 60-65% without sacrificing quality.

​
On-Chain Subscription Model

Subscriptions are stored on Solana blockchain using Program Derived Addresses (PDAs): 
PDA = derive(["subscription", userWalletAddress])
Each subscription PDA contains:
  • tier: Enum (Free = 0, Pro = 1, Enterprise = 2)
  • expiresAt: Unix timestamp
  • isActive: Boolean
  • owner: User’s wallet address
Blockchain is the source of truth for entitlement. Backend caches subscription status for performance.

​
Subscribe to a Tier

​
1. Check Current Status

Before subscribing, check your current subscription status: 
const response = await fetch("/api/subscription/status", {
  headers: { "Authorization": `Bearer ${token}` },
});

const { tier, expires_at, is_active } = await response.json();

if (is_active) {
  console.log(`Current tier: ${tier}, expires: ${new Date(expires_at)}`);
}

​
2. Subscribe (Frontend)

Call the Anchor program to create/update subscription: 
import { createSubscription } from "@/generated/vault";
import { useWalletConnection } from "@solana/react-hooks";

async function subscribe(tier: 0 | 1 | 2) {
  const { wallet, connection } = useWalletConnection();
  
  const instruction = createSubscription({
    tier,
    duration: 30, // days
  });
  
  const signature = await wallet.sendTransaction(
    new Transaction().add(instruction),
    connection
  );
  
  await connection.confirmTransaction(signature);
  return signature;
}

​
3. Backend Verification

After blockchain transaction confirms, backend picks it up via webhook or polling:

​
Subscription Caching

Backend caches subscription state to avoid querying blockchain on every request: 
// Backend service
async function getSubscriptionStatus(walletAddress: string) {
  // Check cache first
  const cached = await db.query(
    "SELECT * FROM subscriptions WHERE wallet_address = $1 AND updated_at > NOW() - INTERVAL '120 seconds'",
    [walletAddress]
  );
  
  if (cached.rows.length > 0) {
    return cached.rows[0]; // Return cached
  }
  
  // Cache miss or stale - refresh from chain
  return await refreshSubscriptionFromChain(walletAddress);
}
Default cache TTL is 120 seconds. Configurable via SUBSCRIPTION_CACHE_TTL_SECONDS env var.

​
Usage Enforcement

Backend middleware validates subscription + usage limits on every request: 
// Middleware chain
app.use(verifyJWT);           // 1. Validate JWT token
app.use(checkSubscription);   // 2. Check subscription active
app.use(checkUsageLimits);    // 3. Validate within tier limits
Example enforcement flow: 
async function checkUsageLimits(req, res, next) {
  const { userId, tier } = req.user;
  
  // Get tier limits from database
  const limits = await db.query(
    "SELECT daily_requests FROM tier_config WHERE tier = $1",
    [tier]
  );
  
  // Count today's usage
  const usage = await db.query(
    "SELECT COUNT(*) FROM api_requests WHERE user_id = $1 AND created_at > NOW() - INTERVAL '1 day'",
    [userId]
  );
  
  if (usage.rows[0].count >= limits.rows[0].daily_requests) {
    return res.status(403).json({ error: "Daily request limit exceeded" });
  }
  
  next();
}

​
Upgrade/Downgrade Tier

To change tiers, submit a new subscription transaction: 
// Upgrading to Enterprise
await subscribe(2); // tier 2 = Enterprise

// Backend automatically detects the change on next cache refresh
Tier changes take effect after blockchain confirmation + next cache refresh (up to 120 seconds).

​
Cancel Subscription

To cancel, submit a cancellation transaction: 
const instruction = cancelSubscription();
const signature = await wallet.sendTransaction(
  new Transaction().add(instruction),
  connection
);
After cancellation:
  • Existing instances continue running until expiration
  • No new instances can be created
  • API access disabled after expires_at timestamp

​
Renewal

Subscriptions auto-renew if you maintain sufficient SOL balance: 
// Blockchain program checks on each request
if (subscription.expiresAt < now) {
  if (user.balance >= subscription.tier.price) {
    subscription.expiresAt += 30 days;
    user.balance -= subscription.tier.price;
  } else {
    subscription.isActive = false;
  }
}
Set up automatic top-ups in your wallet to ensure uninterrupted service.

​
Check Subscription in API

​
HTTP Headers

Every API response includes subscription headers: 
X-Subscription-Tier: pro
X-Subscription-Expires: 2026-03-15T10:30:00Z
X-Usage-Remaining: 8543

​
Status Endpoint

Get full subscription details: 
curl -H "Authorization: Bearer $TOKEN" \
  https://api.agentik.dev/api/subscription/status
Response: 
{
  "wallet_address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
  "tier": "pro",
  "is_active": true,
  "expires_at": "2026-03-15T10:30:00Z",
  "instances_used": 2,
  "instances_limit": 5,
  "requests_today": 1457,
  "requests_limit": 10000
}

​
Troubleshooting

  • Check you have enough SOL (tier price + ~0.000005 SOL fee)
  • Ensure you’re on the mainnet-beta network
  • Verify program ID matches deployed program
  • Wait up to 120 seconds for cache refresh
  • Force refresh: Call POST /api/subscription/refresh
  • Check blockchain explorer for transaction status
  • Check /api/usage/metrics for current usage
  • Upgrade to higher tier if consistently hitting limits
  • Limits reset daily at 00:00 UTC

​
Next Steps

Deploy Instances

Learn how to create and manage AI agent instances