Cost Optimization (REVISIT)

Overview

Pullbay's credit-based pricing model rewards efficient API usage. This guide provides 7 proven optimization strategies with code examples to reduce your monthly credit costs by 50-90%. Whether you're just starting or scaling to thousands of requests, these techniques apply to every usage pattern.

---

Understand Your Usage First

Before optimizing, understand where you're spending credits. Most of Pullbay's dashboard provides a usage breakdown by endpoint.

Steps to analyze your usage:

1. Log into your Pullbay dashboard

2. Navigate to Usage & Analytics

3. View breakdown by endpoint, date range, and request volume

4. Identify top-spending endpoints (usually reviews, search results, business info)

5. Look for spikes or anomalies

Questions to ask:

• Which endpoints consume the most credits?

• Are there spikes at certain times?

• How many requests do you make per day?

• How many pages per request do you typically fetch?

Once you identify patterns, apply the optimization strategies below to your top-spending endpoints first.

---

7 Optimization Strategies

Strategy 1: Fetch Only What You Need (Best ROI)

Impact: 50-90% credit savings

This single strategy delivers the highest return on investment. Stop fetching data you don't use.

Problem: Over-fetching

# BAD: Fetches ALL 5,000 reviews when you only display 50
all_reviews = []
for review in paginator.paginate("reviews", params={"business_id": "12345"}):
    all_reviews.append(review)

# Later: use only the first 50 for your dashboard
recent_reviews = all_reviews[:50]

print(f"Fetched {len(all_reviews)}, but used only {len(recent_reviews)}")
# Output: Fetched 5000, but used only 50 (99% wasted credits!)

Solution: Fetch with a Limit

# GOOD: Stop after 50 reviews
recent_reviews = []
for review in paginator.paginate(
    "reviews",
    params={"business_id": "12345"}
):
    recent_reviews.append(review)

    if len(recent_reviews) >= 50:
        break  # Stop here!

print(f"Fetched exactly {len(recent_reviews)} reviews")
# Output: Fetched exactly 50 reviews (100% efficient)

Or use built-in max_results parameter:

# BEST: Uses built-in limit (stops at API level)
recent_reviews = list(paginator.paginate(
    "reviews",
    params={"business_id": "12345"},
    max_results=50  # API stops fetching after 50
))

Real-world Savings Example

Scenario	Without Limit	With Limit	Savings
Dashboard display (50 items)	5,000 items fetched	50 items fetched	99%
Weekly export (500 items)	10,000 items fetched	500 items fetched	95%
Monthly report (1,000 items)	2,000 items fetched	1,000 items fetched	50%

Annual credit example:

• 10 apps × 40 pages × 30 days = 12,000 credits/month (full fetch)

• With 50-item limit per app (from 5,000 items): 240 credits/month

• Savings: ~11,760 credits/month (98%)

When to use this strategy:

• Displaying top-N results (top 10 reviews, top 50 search results)

• Sampling data (get 100 items to test quality)

• Pagination in web applications (show 50 per page, fetch more on demand)

• Any time you know your maximum needed result count

---

Strategy 2: Cache Responses (50% Credit Savings with 50% Hit Rate)

Impact: 30-70% credit savings

Cache API responses so repeated requests don't consume credits.

Simple TTL-based Caching

import json
import time
import os
from datetime import datetime, timedelta

class ReviewCache:
    def __init__(self, cache_dir="./cache", ttl_seconds=3600):
        self.cache_dir = cache_dir
        self.ttl = ttl_seconds
        os.makedirs(cache_dir, exist_ok=True)

    def _cache_key(self, business_id):
        """Generate cache filename."""
        return os.path.join(self.cache_dir, f"reviews_{business_id}.json")

    def get(self, business_id):
        """Get cached reviews if valid."""
        cache_file = self._cache_key(business_id)

        if not os.path.exists(cache_file):
            return None

        # Check if cache is still fresh
        file_age = time.time() - os.path.getmtime(cache_file)
        if file_age > self.ttl:
            return None  # Cache expired

        with open(cache_file) as f:
            return json.load(f)

    def set(self, business_id, reviews):
        """Cache reviews."""
        cache_file = self._cache_key(business_id)

        with open(cache_file, 'w') as f:
            json.dump(reviews, f)

    def get_or_fetch(self, business_id):
        """Get from cache or fetch from API."""
        # Try cache first
        cached = self.get(business_id)
        if cached:
            print(f"Cache hit: {business_id}")
            return cached

        # Fetch from API
        print(f"Cache miss: {business_id}, fetching from API")
        reviews = managed_paginator.fetch_all(
            "reviews",
            params={"business_id": business_id}
        )

        # Store in cache
        self.set(business_id, reviews)
        return reviews

# Usage
cache = ReviewCache(ttl_seconds=3600)  # 1-hour cache

# First call: fetches from API (costs 100 credits)
reviews_1 = cache.get_or_fetch("12345")

# Second call (within 1 hour): serves from cache (costs 0 credits)
reviews_2 = cache.get_or_fetch("12345")

print(f"Second call saved 100 credits!")

Savings Calculation

Assumptions:

• Fetch 100 reviews per business = 100 credits

• Average 50% cache hit rate

• 100 requests/month

Without caching: 100 requests × 100 credits = 10,000 credits/month
With caching (50% hits): 50 requests × 100 credits = 5,000 credits/month
Savings: 50% (5,000 credits saved)

When to use this strategy:

• Repeated requests for the same business

• Data that doesn't change frequently

• User dashboards that refresh multiple times daily

• Batch jobs that re-query the same data

Choose TTL based on data freshness:

# Real-time data: 5-minute cache
cache = ReviewCache(ttl_seconds=300)

# Hourly dashboard: 1-hour cache
cache = ReviewCache(ttl_seconds=3600)

# Daily batch: 24-hour cache
cache = ReviewCache(ttl_seconds=86400)

# Monthly reports: 7-day cache
cache = ReviewCache(ttl_seconds=604800)

---

Strategy 3: Batch Related Requests

Impact: 30-60% credit savings

Combine multiple related queries into fewer API calls using Managed pagination and smart filtering.

Problem: Multiple Separate Requests

# BAD: 3 separate requests to fetch reviews for 3 businesses
business_ids = ["12345", "12346", "12347"]

for business_id in business_ids:
    # Each call is separate (no batch)
    reviews = managed_paginator.fetch_all(
        "reviews",
        params={"business_id": business_id}
    )
    # 100 credits × 3 = 300 credits total

Solution: Batch with Filtering

# GOOD: Single request with batch processing
# Fetch reviews for all businesses, filter client-side
all_reviews = managed_paginator.fetch_all(
    "reviews",
    params={
        # Batch parameter: fetch for multiple IDs
        "business_ids": ["12345", "12346", "12347"],
        # Limit to recent reviews only
        "created_after": "2024-01-01"
    }
)

# Process by business
by_business = {}
for review in all_reviews:
    business_id = review['business_id']
    if business_id not in by_business:
        by_business[business_id] = []
    by_business[business_id].append(review)

# ~200 credits (vs 300 with 3 separate requests)
# Savings: 33%

Batch + Cache Pattern

class BatchedReviewFetcher:
    def __init__(self, paginator, cache, batch_size=10):
        self.paginator = paginator
        self.cache = cache
        self.batch_size = batch_size

    def fetch_reviews_batch(self, business_ids):
        """Fetch reviews for multiple businesses in batches."""

        all_results = {}

        for i in range(0, len(business_ids), self.batch_size):
            batch = business_ids[i:i+self.batch_size]

            # Try cache first
            cached_batch = []
            to_fetch = []

            for bid in batch:
                cached = self.cache.get(bid)
                if cached:
                    all_results[bid] = cached
                else:
                    to_fetch.append(bid)

            # Fetch uncached items in batch
            if to_fetch:
                batch_reviews = self.paginator.fetch_all(
                    "reviews",
                    params={"business_ids": to_fetch}
                )

                # Separate by business and cache
                for review in batch_reviews:
                    bid = review['business_id']
                    if bid not in all_results:
                        all_results[bid] = []
                    all_results[bid].append(review)

                    # Cache individual business results
                    self.cache.set(bid, all_results[bid])

        return all_results

# Usage
fetcher = BatchedReviewFetcher(managed_paginator, cache, batch_size=10)

business_ids = ["12345", "12346", "12347", "12348", "12349"]
reviews_by_business = fetcher.fetch_reviews_batch(business_ids)

# Only fetch what's not cached
# If 3 of 5 are cached: 2 API calls instead of 5
# Savings: 60%

---

Strategy 4: Avoid Duplicate Requests

Impact: 20-50% credit savings

Deduplicate requests using a centralized service class.

Problem: Duplicate Requests

# BAD: Multiple parts of code fetch the same data
class DashboardService:
    def get_reviews(self, business_id):
        return managed_paginator.fetch_all("reviews", {"business_id": business_id})

class ReportService:
    def generate_report(self, business_id):
        # Same request again!
        reviews = managed_paginator.fetch_all("reviews", {"business_id": business_id})

class AlertService:
    def check_alerts(self, business_id):
        # Same request AGAIN!
        reviews = managed_paginator.fetch_all("reviews", {"business_id": business_id})

# Same business data fetched 3 times (300 credits)

Solution: Centralized Service with Caching

class ReviewService:
    """Centralized service for all review operations."""

    def __init__(self, paginator, cache_ttl=3600):
        self.paginator = paginator
        self.cache = ReviewCache(ttl_seconds=cache_ttl)

    def get_reviews(self, business_id, limit=None):
        """Get reviews for a business (cached)."""
        cached = self.cache.get(business_id)
        if cached:
            reviews = cached
        else:
            reviews = self.paginator.fetch_all(
                "reviews",
                params={"business_id": business_id}
            )
            self.cache.set(business_id, reviews)

        if limit:
            return reviews[:limit]
        return reviews

# Usage: Single service instance used everywhere
review_service = ReviewService(managed_paginator)

class DashboardService:
    def get_reviews(self, business_id):
        return review_service.get_reviews(business_id, limit=50)

class ReportService:
    def generate_report(self, business_id):
        return review_service.get_reviews(business_id)

class AlertService:
    def check_alerts(self, business_id):
        return review_service.get_reviews(business_id)

# Same data requested 3 times, fetched only once (100 credits)
# Savings: 67% (200 of 300 credits saved)

Detect Duplicate Requests

import logging

class TrackedReviewService:
    def __init__(self, paginator):
        self.paginator = paginator
        self.cache = ReviewCache()
        self.request_count = {}
        self.logger = logging.getLogger(__name__)

    def get_reviews(self, business_id):
        """Track duplicate requests."""

        # Count requests
        self.request_count[business_id] = self.request_count.get(business_id, 0) + 1

        # Warn on duplicates
        if self.request_count[business_id] > 1:
            self.logger.warning(
                f"Duplicate request for business {business_id} "
                f"(call #{self.request_count[business_id]})"
            )

        return self.cache.get_or_fetch(business_id)

    def print_stats(self):
        """Print request statistics."""
        duplicates = sum(1 for c in self.request_count.values() if c > 1)
        total_requests = sum(self.request_count.values())
        potential_savings = sum(c - 1 for c in self.request_count.values()) * 100

        print(f"Total requests: {total_requests}")
        print(f"Unique businesses: {len(self.request_count)}")
        print(f"Duplicates: {duplicates}")
        print(f"Potential credit savings: {potential_savings} credits")

# Usage
service = TrackedReviewService(managed_paginator)
service.get_reviews("12345")
service.get_reviews("12345")  # Duplicate!
service.get_reviews("12346")

service.print_stats()
# Output:
# Total requests: 3
# Unique businesses: 2
# Duplicates: 1
# Potential credit savings: 100 credits

---

Strategy 5: Schedule Smart (Match Frequency to Data Change Rate)

Impact: 40-80% credit savings

Fetch data only as frequently as it changes. Over-fetching static data wastes credits.

Fetch Frequency Strategy

import schedule
import time
from datetime import datetime

class SmartScheduler:
    def __init__(self, review_service):
        self.service = review_service

    def schedule_optimized(self):
        """Schedule fetches based on data change rate."""

        # Reviews change frequently: check multiple times/day
        schedule.every(2).hours.do(
            self.fetch_and_cache,
            endpoint="reviews",
            business_id="12345",
            reason="Reviews updated frequently"
        )

        # Search results change often: check multiple times/day
        schedule.every(6).hours.do(
            self.fetch_and_cache,
            endpoint="search",
            business_id="12345",
            reason="Search index updates"
        )

        # Business info changes rarely: check daily
        schedule.every().day.at("02:00").do(
            self.fetch_and_cache,
            endpoint="business_info",
            business_id="12345",
            reason="Business info updated daily"
        )

        # Photos rarely change: check weekly
        schedule.every().monday.at("03:00").do(
            self.fetch_and_cache,
            endpoint="photos",
            business_id="12345",
            reason="Photos updated weekly"
        )

        # Run scheduler
        while True:
            schedule.run_pending()
            time.sleep(60)

    def fetch_and_cache(self, endpoint, business_id, reason):
        """Fetch data and cache it."""
        print(f"[{datetime.now()}] Fetching {endpoint} - {reason}")
        self.service.fetch_and_cache(endpoint, business_id)

# Usage
scheduler = SmartScheduler(review_service)
scheduler.schedule_optimized()

Frequency Recommendations by Data Type

Data Type	Change Frequency	Recommended Check	Monthly Requests	Savings vs Every Hour
Reviews	Every few hours	Every 2-3 hours	240	84%
Search results	Every 6-12 hours	Every 6 hours	120	92%
Business info	Daily	Once daily	30	98%
Photos	Weekly	Once weekly	4	99%
Categories	Monthly	Once monthly	1	99.7%

Example: Optimization Impact

Reviews (change every 2 hours):
  - Bad: Check every hour = 24 × 30 = 720 requests/month
  - Good: Check every 2 hours = 12 × 30 = 360 requests/month
  - Savings: 50%

Business info (changes daily):
  - Bad: Check every 6 hours = 4 × 30 = 120 requests/month
  - Good: Check once daily = 1 × 30 = 30 requests/month
  - Savings: 75%

Combined monthly impact:
  - Bad: 840 requests = 840 credits
  - Good: 390 requests = 390 credits
  - Savings: 54%

---

Strategy 6: Use Test Keys for Development

Impact: 100% savings on dev costs

Never use production credits for development. Use test keys to prototype without cost.

Setting Up Test Keys

import os
from dotenv import load_dotenv

load_dotenv()

# Production key: Real credits consumed
PROD_API_KEY = os.getenv("PULLBAY_API_KEY_PROD")

# Test key: No credits consumed, limited data
TEST_API_KEY = os.getenv("PULLBAY_API_KEY_TEST")

def get_client(use_production=False):
    """Get Pullbay client with appropriate key."""
    api_key = PROD_API_KEY if use_production else TEST_API_KEY

    return PullbayClient(api_key=api_key)

# Development
dev_client = get_client(use_production=False)

# Production
prod_client = get_client(use_production=True)

Test Key Best Practices

class DevelopmentPullbay:
    """Use only in development/testing."""

    def __init__(self):
        self.client = PullbayClient(api_key=os.getenv("PULLBAY_API_KEY_TEST"))
        # Test keys have limits
        self.max_requests_per_hour = 100
        self.max_items_per_request = 50

    def fetch_reviews(self, business_id, limit=10):
        """Fetch limited reviews for testing."""
        return self.client.fetch_all(
            "reviews",
            params={
                "business_id": business_id,
                "max_results": limit  # Limit to 10 for fast testing
            }
        )

    def test_pagination(self, business_id):
        """Test pagination logic without high costs."""
        reviews = []
        cursor = None

        while len(reviews) < 50:  # Stop at 50 for testing
            page = self.client.paginate(
                "reviews",
                params={"business_id": business_id},
                cursor=cursor,
                limit=10
            )

            reviews.extend(page['data'])
            cursor = page['pagination'].get('next_cursor')

            if not cursor:
                break

        return reviews

# Usage
dev_client = DevelopmentPullbay()

# Fast iteration without cost
dev_reviews = dev_client.fetch_reviews("12345", limit=10)
print(f"Development: Fetched {len(dev_reviews)} reviews (0 credits used)")

Cost Comparison

Development with production key:
  - 10 days of testing
  - 100 requests/day, 100 items/request
  - Cost: 100,000 credits consumed

Development with test key:
  - Same work, same testing
  - Cost: 0 production credits consumed

Savings: 100,000 credits per development sprint

---

Strategy 7: Monitor and Alert (Prevent Runaway Spending)

Impact: Prevents 100-1,000+ credit waste from bugs

Set up monitoring to catch unusual usage patterns before they drain your account.

Basic Alert System

import time
from datetime import datetime, timedelta

class CreditMonitor:
    def __init__(self, client, alert_thresholds=None):
        self.client = client
        self.thresholds = alert_thresholds or {
            'percent_50': 50,      # Alert at 50% of monthly budget
            'percent_75': 75,      # Critical at 75%
            'daily_spike': 2.0     # Alert if 2× higher than daily average
        }
        self.daily_history = []

    def check_and_alert(self):
        """Check usage and send alerts if needed."""
        usage = self.client.get_usage()

        # Alert 1: Percent of monthly budget
        percent_used = (usage['credits_used'] / usage['monthly_budget']) * 100

        if percent_used >= self.thresholds['percent_75']:
            self._send_alert(
                f"CRITICAL: {percent_used:.1f}% of monthly budget used",
                severity='critical'
            )
        elif percent_used >= self.thresholds['percent_50']:
            self._send_alert(
                f"WARNING: {percent_used:.1f}% of monthly budget used",
                severity='warning'
            )

        # Alert 2: Daily spending spike
        today_usage = usage['credits_today']
        self.daily_history.append((datetime.now(), today_usage))

        if len(self.daily_history) >= 7:
            avg_daily = sum(c for _, c in self.daily_history[-7:]) / 7
            spike_multiplier = today_usage / max(avg_daily, 1)

            if spike_multiplier >= self.thresholds['daily_spike']:
                self._send_alert(
                    f"Alert: Today's usage ({today_usage} credits) is "
                    f"{spike_multiplier:.1f}x daily average ({avg_daily:.0f})",
                    severity='warning'
                )

    def _send_alert(self, message, severity='info'):
        """Send alert via email/Slack/etc."""
        print(f"[{severity.upper()}] {message}")

        # TODO: Integrate with email/Slack/PagerDuty
        # send_email(alert_recipients, subject=f"Pullbay {severity}", body=message)
        # post_slack(message, channel=alerts_channel)

# Usage
monitor = CreditMonitor(
    client=pullbay_client,
    alert_thresholds={
        'percent_50': 50,
        'percent_75': 75,
        'daily_spike': 2.0
    }
)

# Run periodically (every hour)
schedule.every().hour.do(monitor.check_and_alert)

Production Monitoring Checklist

class ProductionMonitoring:
    """Comprehensive monitoring for production."""

    @staticmethod
    def setup_alerts():
        """Set up all recommended alerts."""

        alerts = [
            {
                'name': '50% budget alert',
                'condition': 'credits_used > (monthly_budget * 0.5)',
                'recipients': ['[email protected]']
            },
            {
                'name': '75% budget alert',
                'condition': 'credits_used > (monthly_budget * 0.75)',
                'recipients': ['[email protected]', '[email protected]']
            },
            {
                'name': '2x daily spike',
                'condition': 'credits_today > (avg_daily_credits * 2)',
                'recipients': ['[email protected]']
            },
            {
                'name': 'API errors spike',
                'condition': 'error_rate_1h > 5%',
                'recipients': ['[email protected]']
            },
            {
                'name': 'Rate limit hits',
                'condition': 'rate_limit_hits_1h > 10',
                'recipients': ['[email protected]']
            }
        ]

        for alert in alerts:
            print(f"Configured alert: {alert['name']}")
            print(f"  Recipients: {alert['recipients']}")

    @staticmethod
    def log_metrics():
        """Log detailed metrics."""
        metrics = {
            'timestamp': datetime.now().isoformat(),
            'credits_used_today': 0,
            'requests_made_today': 0,
            'avg_credits_per_request': 0,
            'top_endpoints': [],
            'error_rate': 0,
        }

        # Log to monitoring system (DataDog, New Relic, etc.)
        print(f"Metrics: {metrics}")

---

Cost Estimation Formula

Estimate your monthly credit usage with this formula:

Monthly Credits = (Requests Per Endpoint) × (Pages Per Request) × (Frequency Per Month)

Example 1: Single Business, All Reviews
  Requests = 1
  Pages = 40 pages (at 50 items/page = 2,000 reviews)
  Frequency = 30 (once daily)
  Monthly Credits = 1 × 40 × 30 = 1,200 credits

Example 2: Multiple Apps (10 apps), Daily Reviews
  Reviews: 10 apps × 40 pages × 30 days = 12,000 credits/month

Example 3: With Optimization (Same Use Case, With Caching)
  Reviews (50% cache hits): 12,000 × 0.5 = 6,000 credits/month
  Savings: 6,000 credits/month (50%)

---

Cost Estimation Spreadsheet

Create a spreadsheet to track and estimate costs:

| Endpoint | Freq | Pages | Requests/Mo | Credits/Request | Monthly Credits | Notes |
|----------|------|-------|-------------|-----------------|-----------------|-------|
| Reviews | Daily | 40 | 300 | 40 | 12,000 | 10 apps |
| Reviews (cached) | Daily | 40 | 150 | 40 | 6,000 | 50% cache hit |
| TOTAL (no cache) | | | | | 12,000 | |
| TOTAL (with cache) | | | | | 6,000 | 50% saving |

---

When to Upgrade vs When to Optimize

Upgrade Plan if:

• Legitimate high usage (not bugs or inefficiency)

• Usage expected to grow significantly

• Current plan is limiting features (rate limits)

• Cost per credit becomes favorable at higher volumes

Example: Should You Upgrade?

Current usage: 50,000 credits/month — consistently hitting rate limits.

Options:
1. Optimize usage — reduce waste, implement caching, limit over-fetching
2. Upgrade plan — higher rate limits, more monthly credits included

If hitting rate limits regularly: upgrade for higher req/min limits.
If over-fetching data: optimize first before upgrading.

See the Plans guide for specific plan details and pricing.

Optimize if:

• You have wasteful patterns (duplicates, over-fetching, infrequent changes fetched hourly)

• Current usage seems excessive for your use case

• Easy optimizations available (caching, limiting)

---

Build vs Buy: Pullbay vs Custom Scrapers

Building and maintaining your own scrapers involves:

• Significant development time upfront

• Ongoing maintenance as source websites change

• Proxy infrastructure and anti-bot handling

• Monitoring for failures and schema changes

Pullbay handles all of this automatically. Your engineering time is spent on using the data, not maintaining the pipeline.

When evaluating total cost, factor in: developer hours for initial build, ongoing maintenance hours per month, infrastructure costs (proxies, servers), and the reliability risk when sites change structure.

---

FAQ

What's the cheapest way to test the API?

Use test keys with limited data:

# Test key (no credits used)
test_client = PullbayClient(api_key=os.getenv("PULLBAY_API_KEY_TEST"))

# Fetch limited sample
sample = test_client.fetch_all(
    "reviews",
    params={
        "business_id": "12345",
        "max_results": 10  # Small sample for testing
    }
)

print(f"Got {len(sample)} reviews, cost: 0 credits")

Test keys include:

• 100 requests/hour limit

• 50 items/request soft limit

• Simulated data similar to production

• Zero credit cost

How do I estimate my monthly credit usage?

Use the formula:

Monthly Credits = Requests × Pages × Frequency

Examples:
- One business, daily: 1 × 40 × 30 = 1,200 credits
- Ten businesses, hourly: 10 × 5 × 24 × 30 = 36,000 credits
- Five endpoints, daily: (5 × 20 pages × 30) = 3,000 credits

Or create a test run:

import time

start_credits = client.get_account()['credits']
start_time = time.time()

# Run your typical workload
perform_typical_usage()

elapsed = time.time() - start_time
credits_used = start_credits - client.get_account()['credits']

daily_requests = requests_made / (elapsed / 86400)
monthly_estimate = (credits_used / requests_made) * (daily_requests * 30)

print(f"Estimated monthly usage: {monthly_estimate:.0f} credits")

Can I set a credit spending limit?

Most plans support spending limits. Check your dashboard:

1. Go to Settings > Billing

2. Set Monthly Spending Limit

3. Receive alerts when approaching limit

4. Automatic cutoff when limit reached

Programmatic alert instead:

def check_budget(client, monthly_budget=5000, current_usage=None):
    if current_usage is None:
        current_usage = client.get_usage()['credits_used']

    percent_used = (current_usage / monthly_budget) * 100

    if percent_used >= 100:
        raise Exception("Monthly budget exceeded!")
    elif percent_used >= 75:
        send_alert(f"WARNING: {percent_used:.0f}% of budget used")

    return percent_used

# Usage
percent = check_budget(client, monthly_budget=5000)
print(f"Budget used: {percent:.0f}%")

---

Summary

Implement these strategies in order of impact:

1. Fetch only what you need (50-90% savings) - Highest ROI

2. Cache responses (30-70% savings) - Quick to implement

3. Batch related requests (30-60% savings) - Plan ahead

4. Avoid duplicates (20-50% savings) - Refactor for clarity

5. Schedule smart (40-80% savings) - Match frequency to data changes

6. Use test keys (100% dev savings) - Never use production credits

7. Monitor and alert (Prevents waste) - Catch bugs early

Combined impact: 50-90% monthly credit reduction while improving performance and code quality.

Start with strategies 1 and 2 for immediate impact. Add the others as your usage scales.