Plan Usage & Limits

Understanding how Deep Mod tracks and manages your usage helps you stay within plan limits and optimize your content moderation costs. This section explains how credits work, what happens when you approach limits, and how notifications keep you informed.

How Usage is Measured

Credits: The Billing Unit

Deep Mod uses credits as the billing unit. Credits reflect the actual cost of processing your content based on two factors:

1. Base charge: Every moderation run costs a minimum of 100 credits

2. Variable charge: Scales with content length and policy complexity

The Credit Formula

Each moderation run (content evaluated against one policy) is calculated as:

Credits = 100 + (ceil(Words / 100) x Rules)

Where:

• 100 is the fixed base charge per moderation run

• Words is the word count of your content

• Rules is the number of rules in the policy

• ceil means round up to the nearest whole number

Why the Base Charge?

The 100-credit base charge exists because every moderation run has fixed processing overhead regardless of content size. This ensures fair pricing whether you're moderating a single word or a full article.

Credit Calculation Examples

Single Policy Moderations:

Batch Mode (Policy Chaining):

When you moderate content against multiple policies in one request, each policy creates a separate moderation run with its own base charge:

Batch Calculation Example (2,500 words, 3 policies with 15 rules each):

Policy 1: 100 + (ceil(2500/100) x 15) = 100 + (25 x 15) = 475 credits
Policy 2: 100 + (ceil(2500/100) x 15) = 100 + (25 x 15) = 475 credits
Policy 3: 100 + (ceil(2500/100) x 15) = 100 + (25 x 15) = 475 credits
Total: 1,425 credits (3 moderation runs)

Human Reviews

Human reviews update existing moderation runs rather than creating new usage:

• Reviews modify the original moderation run that was already counted

• No additional credits are charged for human review decisions

• Reviews are tracked for analytics but don't count toward credit limits

Usage Periods

Monthly Billing Cycles: Usage resets at the start of each billing period based on your subscription start date, not calendar months.

Real-Time Tracking: Credit usage is updated immediately as each moderation run completes.

Plan Credit Limits

Each plan includes a monthly credit allocation:

What the Limits Mean

Free Plan (25,000 credits):

• Minimum moderations: ~250 (at 100 credits each)

• Typical moderations: ~165 (500 words, 10 rules = 150 credits each)

Starter Plan (2,500,000 credits):

• Minimum moderations: ~25,000 (at 100 credits each)

• Typical moderations: ~16,600 (500 words, 10 rules = 150 credits each)

Professional Plan (5,000,000 credits):

• Minimum moderations: ~50,000 (at 100 credits each)

• Typical moderations: ~33,300 (500 words, 10 rules = 150 credits each)

Enterprise Plan (15,000,000 credits):

• Minimum moderations: ~150,000 (at 100 credits each)

• Typical moderations: ~100,000 (500 words, 10 rules = 150 credits each)

Notifications and Alerts

Deep Mod proactively notifies you as you approach and reach your usage limits.

Notification Thresholds

80% Warning

When your credit usage reaches 80% of your monthly limit:

• In-app notification appears for all organization members

• Email alert sent to organization administrators

• Message: "Your organization has used 80% of your monthly credits. Consider upgrading to avoid service interruption."

100% Limit Reached

When your credit usage reaches 100% of your monthly limit:

• In-app notification appears for all organization members

• Email alert sent to organization administrators

• API requests blocked until the next billing period or plan upgrade

• Message: "Your organization has reached its monthly credit limit. Moderation requests are blocked until your next billing period or plan upgrade."

API Response When Usage Limit Reached

When you exceed your credit limit, API moderation requests return:

HTTP 429 Too Many Requests

{
  "errors": [
    {
      "code": "E_USAGE_LIMIT_REACHED",
      "message": "You have reached your monthly moderation limit for your subscription. Please upgrade your subscription to increase your limit."
    }
  ]
}

Important: This error indicates you've exhausted your monthly credits. Unlike rate limit errors, this should not be retried—instead, upgrade your plan or wait for the next billing period.

Optimizing Credit Usage

Reducing Credit Costs

Content Filtering: Pre-filter obviously acceptable content before sending to Deep Mod. If content clearly doesn't need moderation, don't send it.

Policy Optimization:

• Keep policies focused with only necessary rules

• More rules = more credits per moderation

• Consider whether all rules are actively needed

Policy Chaining Awareness:

• Each policy in a chain multiplies your credit usage

• Use batch mode only when multiple policies are truly necessary

• Consider combining related rules into a single policy instead of chaining separate policies

Content Preparation:

• Remove unnecessary boilerplate text (headers, footers, legal disclaimers)

• Clean formatting and extra whitespace

• Split very long documents at logical breaks if separate moderation is acceptable

Efficient Batching Strategies

Since each moderation run has a 100-credit base charge, efficiency comes from:

1. Moderate meaningful content: Avoid submitting empty or near-empty content

2. Right-size your policies: More rules cost more, so only include rules you need

3. Strategic policy chaining: Only chain when necessary; consolidate when possible

Example: Efficient vs. Inefficient Usage

Inefficient (separate policies):

• Policy A: 5 safety rules

• Policy B: 5 legal rules

• Policy C: 5 brand rules

• 500-word content through all three: 100 + (5x5) + 100 + (5x5) + 100 + (5x5) = 375 credits

Efficient (combined policy):

• Single policy: 15 rules (safety + legal + brand)

• 500-word content: 100 + (5x15) = 175 credits

Savings: 200 credits per moderation (54% reduction)

API Rate Limits

Separate from credit limits, API rate limits control request frequency to ensure system stability. Rate limits restrict how many requests you can make per minute, while credit limits restrict your total monthly usage.

Rate Limit Response Headers

Every API response includes headers to help you monitor your rate limit status:

Use these headers to proactively monitor your usage and avoid hitting limits.

Rate Limit Error Response

When you exceed your rate limit, the API returns:

HTTP 429 Too Many Requests

Headers:

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 45
Retry-After: 45

Body:

{
  "error": "Rate limit exceeded",
  "message": "Too many requests. Please try again later.",
  "retryAfter": "45 seconds"
}

Note: This is different from a usage limit error. Rate limit errors are temporary and can be retried after waiting.

Handling Rate Limits vs Usage Limits

Both rate limits and usage limits return HTTP 429, but they require different handling:

Implement exponential backoff retry logic for rate limits:

async function submitWithRetry(policyUri, content, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch('https://api.deepmod.ai/v1/moderation/run', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${API_TOKEN}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ policyUri, content })
      });

      if (response.status === 429) {
        const data = await response.json();

        // Check if this is a usage limit (don't retry) vs rate limit (retry)
        if (data.errors?.[0]?.code === 'E_USAGE_LIMIT_REACHED') {
          throw new Error('Monthly usage limit reached. Please upgrade your plan.');
        }

        // Rate limit - wait and retry
        const retryAfter = response.headers.get('Retry-After') || 60;
        if (attempt < maxRetries) {
          await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
          continue;
        }
        throw new Error('Rate limited');
      }

      return await response.json();
    } catch (error) {
      if (attempt === maxRetries) throw error;

      const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

Best Practices

• Monitor headers: Check X-RateLimit-Remaining to proactively slow down before hitting limits

• Request spacing: Distribute API calls evenly rather than sending bursts

• Error handling: Distinguish between rate limit errors (retry) and usage limit errors (don't retry)

• Queue management: Implement request queuing for high-volume applications

Monitoring Your Usage

Dashboard Analytics

The usage dashboard shows:

• Current period usage: Credits used vs. credit limit

• Usage percentage: Visual progress toward limit

• Historical trends: Usage patterns over past billing periods

• Breakdown by policy: Which policies consume the most credits

Forecasting

Use your usage data to:

• Project monthly needs: Track daily averages to predict monthly totals

• Plan upgrades: Identify when you're consistently approaching limits

• Optimize policies: Find high-usage policies that might benefit from optimization

What's Next

• Troubleshooting - Common usage and limit issues and solutions

Effective usage management ensures your content moderation runs smoothly while staying within budget and plan constraints.

Questions about usage or limits? Contact support for help with plan selection, usage optimization, or limit management strategies.