AWS Bedrock for SaaS - Monetize AI, Pass Costs Downstream & Profit

Bedrock gives you 50+ models from $0.035/MTok - the margin opportunity is in how you package and sell access

Bedrock Pricing - Your Cost of Goods Sold

Bedrock charges per token consumed - API calls themselves are free. Your COGS is the raw token cost. Here are the models that matter for SaaS:

Production-Ready Models (Best Quality/Cost Ratio)

Cost Reduction Levers

Monetization Models

1. Tiered Subscription + Usage Caps

The most common model. Predictable revenue with built-in upsell:

2. Credit System

Sell credit packs that map to underlying token consumption. This is how Jasper, Copy.ai, and Writesonic work:

Credit Pack Pricing:
  100 credits  = $10   ($0.10/credit)
  500 credits  = $39   ($0.078/credit)
  2,000 credits = $99  ($0.050/credit)

Credit Consumption (hidden from user):
  Simple task (Nova Micro, ~500 tokens)  = 1 credit   → costs you $0.00003
  Standard task (Nova Pro, ~1K tokens)   = 5 credits   → costs you $0.004
  Premium task (Sonnet, ~1K tokens)      = 20 credits  → costs you $0.018

At $0.10/credit, a "Premium task" earns $2.00 on $0.018 COGS = 99.1% margin

3. Usage-Based (Per-Unit Pricing)

Charge per document, per conversation, per analysis - abstract away tokens entirely:

4. Markup Model (API Resale)

Simplest model - buy tokens wholesale from Bedrock, sell at 3-10× markup through your API:

Your cost:  Claude Sonnet 4.6 = $3.00 input / $15.00 output per MTok
You charge: $15.00 input / $60.00 output per MTok (5× markup)
Margin:     80%

With routing (70% to Haiku at $0.25/$1.25):
Blended cost: ~$1.08/$5.38 per MTok
You charge:   $10.00/$40.00 per MTok
Margin:       89%

Margin Math - Real Numbers

Scenario: AI Document Processing SaaS

Assumptions:
  - 10,000 paying users at $49/mo (Pro tier)
  - Each user processes ~200 documents/month
  - Each document: ~2K input tokens + ~500 output tokens
  - Model: Nova Pro ($0.80/$3.20 per MTok) for 70%, Sonnet ($3/$15) for 30%

Monthly Revenue:
  10,000 × $49 = $490,000

Monthly Bedrock COGS:
  Total requests: 10,000 × 200 = 2,000,000 documents
  
  Nova Pro (70% = 1,400,000 docs):
    Input:  1.4M × 2K tokens = 2.8B tokens × $0.80/1M  = $2,240
    Output: 1.4M × 500 tokens = 700M tokens × $3.20/1M  = $2,240
    Subtotal: $4,480
  
  Sonnet (30% = 600,000 docs):
    Input:  600K × 2K tokens = 1.2B tokens × $3.00/1M   = $3,600
    Output: 600K × 500 tokens = 300M tokens × $15.00/1M  = $4,500
    Subtotal: $8,100
  
  Total Bedrock: $12,580/month

Other COGS:
  AWS infra (API GW, Lambda, DynamoDB, S3): ~$2,000
  Stripe fees (2.9%): ~$14,210
  Support/ops: ~$5,000
  Total COGS: ~$33,790

Gross Profit: $490,000 - $33,790 = $456,210
Gross Margin: 93.1%
Bedrock as % of revenue: 2.6%

Margin Sensitivity by Model Choice

Metering Architecture

The Stack: API Gateway → Lambda → Bedrock + Metering

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│   Client     │────▶│ API Gateway  │────▶│   Lambda    │
│  (Your App)  │     │  + API Key   │     │  (Router)   │
└─────────────┘     └──────────────┘     └──────┬──────┘
                                                 │
                    ┌────────────────────────────┼────────────────┐
                    │                            │                │
              ┌─────▼─────┐            ┌────────▼────────┐  ┌───▼───┐
              │  Bedrock   │            │   DynamoDB      │  │  SQS  │
              │  (Invoke)  │            │ (Usage Meter)   │  │(Async)│
              └────────────┘            └─────────────────┘  └───────┘

Token Metering Middleware (Python)

import boto3, json, time
from decimal import Decimal

bedrock = boto3.client("bedrock-runtime")
dynamodb = boto3.resource("dynamodb")
usage_table = dynamodb.Table("usage-meters")

# Model cost lookup (per 1M tokens)
MODEL_COSTS = {
    "amazon.nova-micro-v1:0":    {"input": 0.035, "output": 0.14},
    "amazon.nova-pro-v1:0":      {"input": 0.80,  "output": 3.20},
    "anthropic.claude-3-haiku":  {"input": 0.25,  "output": 1.25},
    "anthropic.claude-sonnet-4": {"input": 3.00,  "output": 15.00},
}

def invoke_and_meter(customer_id: str, model_id: str,
                     messages: list, system: str = "") -> dict:
    """Call Bedrock, count tokens, record usage."""
    
    body = {"messages": messages, "max_tokens": 1024}
    if system:
        body["system"] = system

    resp = bedrock.invoke_model(
        modelId=model_id,
        body=json.dumps(body),
        contentType="application/json",
    )
    
    result = json.loads(resp["body"].read())
    
    # Extract token counts from response metadata
    usage = result.get("usage", {})
    input_tokens = usage.get("input_tokens", 0)
    output_tokens = usage.get("output_tokens", 0)
    
    # Calculate cost
    costs = MODEL_COSTS[model_id]
    cost = (input_tokens * costs["input"] / 1_000_000 +
            output_tokens * costs["output"] / 1_000_000)
    
    # Record usage in DynamoDB
    month_key = time.strftime("%Y-%m")
    usage_table.update_item(
        Key={"customer_id": customer_id, "month": month_key},
        UpdateExpression="""
            ADD input_tokens :inp, output_tokens :out,
                total_cost :cost, request_count :one
        """,
        ExpressionAttributeValues={
            ":inp": input_tokens,
            ":out": output_tokens,
            ":cost": Decimal(str(round(cost, 6))),
            ":one": 1,
        },
    )
    
    return result

Smart Model Router

def route_request(messages: list, tier: str = "pro") -> str:
    """Route to cheapest model that can handle the task."""
    
    # Estimate complexity from message length
    total_chars = sum(len(m["content"]) for m in messages)
    
    if tier == "free":
        return "amazon.nova-micro-v1:0"
    
    if total_chars < 500:  # Simple task
        return "amazon.nova-micro-v1:0"      # $0.035/$0.14
    elif total_chars < 2000:  # Medium task
        return "anthropic.claude-3-haiku"     # $0.25/$1.25
    elif tier == "business":  # Complex + premium tier
        return "anthropic.claude-sonnet-4"    # $3/$15
    else:
        return "amazon.nova-pro-v1:0"         # $0.80/$3.20

Cutting Your COGS

1. Model routing - Route 70-90% of requests to Nova Micro/Haiku. Only escalate to Sonnet/Opus for complex tasks. Saves 50-90%.
2. Prompt caching - Cache system prompts and few-shot examples. Reads cost 10% of input price. Saves 50-90% on repeated context.
3. Batch inference - For async features (reports, bulk analysis), use batch API for 50% discount.
4. Flex tier - For latency-tolerant features, Flex tier is 50% off standard pricing.
5. Intelligent Prompt Routing - $1/1K requests. Bedrock auto-routes between models in the same family. Up to 30% savings.
6. S3 Vectors for RAG - Up to 90% cheaper than OpenSearch Serverless for Knowledge Bases.
7. Output token limits - Set max_tokens appropriately. Don't let Sonnet generate 4K tokens when 500 suffice.

AWS Marketplace Distribution

Listing on AWS Marketplace gives you access to enterprise budgets that are otherwise locked behind procurement:

Marketplace Fees

Best listing model for AI SaaS: SaaS Subscription with Usage - base subscription + metered overage. Report usage via the Metering API hourly.

The Complete Playbook