Overages

Overages occur when your usage exceeds your plan’s included limits. How overages are handled depends on your plan.

Overage handling by plan

Plan	Query Overages	Node Overages
Free	Hard limit (blocked)	Hard limit (blocked)
Developer	$0.50 per 1,000 queries	Hard limit (upgrade required)
Pro	$0.30 per 1,000 queries	Hard limit (upgrade required)
Enterprise	Custom pricing	Custom pricing

Query overages

Free plan

When you reach your query limit:

• Additional queries return error: QUOTA_EXCEEDED
• Service resumes on the 1st of next month
• No charges

{
  "error": {
    "code": "QUOTA_EXCEEDED",
    "message": "Monthly query limit reached. Upgrade plan or wait for reset.",
    "limit": 5000,
    "current": 5000,
    "resets_at": "2026-04-01T00:00:00Z"
  }
}

Paid plans (Developer, Pro)

When you exceed your included queries:

• Service continues without interruption
• Additional queries billed at overage rate
• Charges appear on next invoice

Example: Developer plan

• Included: 50,000 queries
• Used: 62,500 queries
• Overage: 12,500 queries
• Overage charge: 12,500 × $0.50/1000 = **$6.25**

Overage rates

Plan	Rate
Developer	$0.50 per 1,000 queries
Pro	$0.30 per 1,000 queries
Enterprise	Custom (volume discounts available)

Node overages

Node limits are hard limits on all plans:

Plan	Node Limit
Free	1,000
Developer	25,000
Pro	100,000
Enterprise	Unlimited

When you hit the node limit

New memory_store operations return an error:

{
  "error": {
    "code": "NODE_LIMIT_EXCEEDED",
    "message": "Node limit reached. Delete nodes or upgrade plan.",
    "limit": 25000,
    "current": 25000
  }
}

Options when at node limit

1. Delete unused nodes — Free up space with memory_forget
2. Archive to external storage — Export subgraphs, then delete
3. Upgrade plan — Get more node capacity

Preventing overages

Set usage alerts

1. Go to Settings → Alerts
2. Configure thresholds:
   • 70% — Warning notification
   • 90% — Critical notification
   • 100% — Limit reached notification

Monitor in real-time

Use the usage API to check before operations:

def check_can_query():
    usage = get_usage()
    remaining = usage['queries']['limit'] - usage['queries']['current']
    return remaining > 0

def check_can_store():
    usage = get_usage()
    remaining = usage['nodes']['limit'] - usage['nodes']['current']
    return remaining > 0

Implement client-side limits

Add safeguards in your application:

class MemoryClient:
    def __init__(self, daily_query_budget=1000):
        self.daily_budget = daily_query_budget
        self.queries_today = 0
        self.last_reset = datetime.now().date()
    
    def recall(self, query):
        self._check_budget()
        result = self._do_recall(query)
        self.queries_today += 1
        return result
    
    def _check_budget(self):
        # Reset if new day
        if datetime.now().date() > self.last_reset:
            self.queries_today = 0
            self.last_reset = datetime.now().date()
        
        if self.queries_today >= self.daily_budget:
            raise Exception("Daily query budget exceeded")

Overage billing

When overages are billed

• Overages accumulate throughout the billing period
• Total overage is calculated at period end
• Charge appears on next invoice

Invoice breakdown

HyperMemory - Developer Plan
-----------------------------
Base plan (March 2026)          $29.00

Overage charges:
  Queries: 62,500 used
  Included: 50,000
  Overage: 12,500
  Rate: $0.50/1,000
  Overage total:                 $6.25

-----------------------------
Total:                          $35.25

Overage caps (Pro plan only)

Pro plans include an optional overage cap:

1. Go to Settings → Billing
2. Set Overage Cap (e.g., $50/month)
3. When cap is reached, behavior changes to hard limit

This prevents unexpected bills while allowing burst usage.

Reducing overage costs

Break-even calculation:

Developer: $29 + $0.50/1K overage Pro: $99 + $0.30/1K overage

Break-even point: ~140,000 additional queries/month

If you consistently use >190,000 queries, Pro is more economical.

Enterprise options

For high-volume users, Enterprise plans offer:

• Volume discounts — Lower per-query rates
• Committed usage — Prepay for guaranteed capacity
• Burst capacity — Handle traffic spikes without overage
• Custom limits — Tailored to your needs

Contact sales@hypermemory.io for custom pricing.

Next steps

Plans

Compare all plans

Managing Subscription

Upgrade or change billing