How to Use Payment Fee Cost Analysis in Stripe: Step-by-Step Tutorial

Step-by-Step Fee Analysis Process

Step 1: Gather Your Stripe Data

The foundation of any fee analysis is accurate, comprehensive transaction data. Stripe provides multiple ways to access this information.

Option A: Export from Stripe Dashboard

1. Log into your Stripe Dashboard
2. Navigate to Payments → All payments
3. Click the Export button in the top right
4. Select your date range (recommend 90 days minimum)
5. Choose columns to include:
   • Amount
   • Fee
   • Net
   • Payment Method Type
   • Card Brand
   • Card Country
   • Currency
   • Status
   • Created Date
6. Download as CSV

Option B: Use Stripe API

For automated or ongoing analysis, use the Stripe API to pull transaction data programmatically:

import stripe
from datetime import datetime, timedelta

stripe.api_key = 'your_secret_key'

# Get charges from last 90 days
ninety_days_ago = int((datetime.now() - timedelta(days=90)).timestamp())

charges = stripe.Charge.list(
    limit=100,
    created={'gte': ninety_days_ago}
)

# Extract fee data
fee_data = []
for charge in charges.auto_paging_iter():
    fee_data.append({
        'id': charge.id,
        'amount': charge.amount / 100,  # Convert from cents
        'fee': sum([fee.amount for fee in charge.balance_transaction.fee_details]) / 100,
        'currency': charge.currency,
        'card_brand': charge.payment_method_details.card.brand if charge.payment_method_details else None,
        'card_country': charge.payment_method_details.card.country if charge.payment_method_details else None,
        'created': datetime.fromtimestamp(charge.created)
    })

Expected Output: A dataset with all transactions including detailed fee information for each charge.

Step 2: Calculate Total Fee Costs

Now that you have your data, calculate the complete fee picture for your analysis period.

Key Calculations

# Calculate core metrics
total_volume = sum(transaction['amount'] for transaction in fee_data)
total_fees = sum(transaction['fee'] for transaction in fee_data)
transaction_count = len(fee_data)

# Calculate effective processing rate
effective_rate = (total_fees / total_volume) * 100

# Calculate average transaction value
avg_transaction = total_volume / transaction_count

# Calculate average fee per transaction
avg_fee = total_fees / transaction_count

print(f"Analysis Results:")
print(f"Total Volume: ${total_volume:,.2f}")
print(f"Total Fees: ${total_fees:,.2f}")
print(f"Transactions: {transaction_count:,}")
print(f"Effective Rate: {effective_rate:.3f}%")
print(f"Avg Transaction: ${avg_transaction:.2f}")
print(f"Avg Fee: ${avg_fee:.2f}")

Expected Output:

Analysis Results:
Total Volume: $487,350.00
Total Fees: $15,124.89
Transactions: 3,241
Effective Rate: 3.103%
Avg Transaction: $150.34
Avg Fee: $4.67

This gives you the baseline understanding of your fee costs. If your effective rate is significantly higher than Stripe's standard 2.9% + 30¢, you've already identified an optimization opportunity.

Step 3: Segment Fees by Payment Method

Not all transactions cost the same. International cards, American Express, and certain payment methods have different fee structures. Breaking down costs by payment type reveals where you're spending most.

Segment by Card Brand

from collections import defaultdict

# Group by card brand
brand_stats = defaultdict(lambda: {'volume': 0, 'fees': 0, 'count': 0})

for transaction in fee_data:
    brand = transaction.get('card_brand', 'unknown')
    brand_stats[brand]['volume'] += transaction['amount']
    brand_stats[brand]['fees'] += transaction['fee']
    brand_stats[brand]['count'] += 1

# Calculate rates by brand
print("Fee Analysis by Card Brand:")
print("-" * 70)
for brand, stats in sorted(brand_stats.items(), key=lambda x: x[1]['fees'], reverse=True):
    effective_rate = (stats['fees'] / stats['volume']) * 100
    avg_fee = stats['fees'] / stats['count']
    print(f"{brand.upper()}")
    print(f"  Volume: ${stats['volume']:,.2f}")
    print(f"  Fees: ${stats['fees']:,.2f}")
    print(f"  Transactions: {stats['count']:,}")
    print(f"  Effective Rate: {effective_rate:.3f}%")
    print(f"  Avg Fee: ${avg_fee:.2f}")
    print()

Expected Output:

Fee Analysis by Card Brand:
----------------------------------------------------------------------
VISA
  Volume: $285,420.00
  Fees: $8,654.38
  Transactions: 1,847
  Effective Rate: 3.032%
  Avg Fee: $4.69

MASTERCARD
  Volume: $128,940.00
  Fees: $3,892.17
  Transactions: 891
  Effective Rate: 3.019%
  Avg Fee: $4.37

AMEX
  Volume: $52,340.00
  Fees: $1,832.90
  Transactions: 312
  Effective Rate: 3.502%
  Avg Fee: $5.87

DISCOVER
  Volume: $20,650.00
  Fees: $745.44
  Transactions: 191
  Effective Rate: 3.610%
  Avg Fee: $3.90

Key Insight: Notice that American Express transactions have a higher effective rate (3.502% vs 3.032% for Visa). This is due to AmEx's higher interchange fees. If AmEx represents a significant portion of your volume, this is an optimization opportunity.

Step 4: Identify Optimization Opportunities

With your fee data segmented, you can now identify specific areas for cost reduction. Let's explore the most common optimization opportunities.

Opportunity 1: International Card Fees

International cards typically incur an additional 1% fee. Identify what percentage of your fees come from international transactions:

# Analyze domestic vs international
domestic_fees = sum(t['fee'] for t in fee_data if t.get('card_country') == 'US')
international_fees = sum(t['fee'] for t in fee_data if t.get('card_country') != 'US')

domestic_volume = sum(t['amount'] for t in fee_data if t.get('card_country') == 'US')
international_volume = sum(t['amount'] for t in fee_data if t.get('card_country') != 'US')

print("Domestic vs International Analysis:")
print(f"Domestic Fees: ${domestic_fees:,.2f} ({(domestic_fees/total_fees)*100:.1f}%)")
print(f"Domestic Rate: {(domestic_fees/domestic_volume)*100:.3f}%")
print(f"\nInternational Fees: ${international_fees:,.2f} ({(international_fees/total_fees)*100:.1f}%)")
print(f"International Rate: {(international_fees/international_volume)*100:.3f}%")
print(f"\nPremium for International: {((international_fees/international_volume)-(domestic_fees/domestic_volume))*100:.3f}%")

Opportunity 2: Small Transaction Optimization

Stripe's 30¢ fixed fee hits small transactions particularly hard. For a $5 transaction, that's 6% in fixed fees alone before the percentage fee is even applied.

# Analyze small transactions
small_tx_threshold = 10.00
small_transactions = [t for t in fee_data if t['amount'] < small_tx_threshold]

if small_transactions:
    small_tx_volume = sum(t['amount'] for t in small_transactions)
    small_tx_fees = sum(t['fee'] for t in small_transactions)
    small_tx_count = len(small_transactions)

    print(f"\nSmall Transaction Analysis (< ${small_tx_threshold}):")
    print(f"Count: {small_tx_count:,} ({(small_tx_count/transaction_count)*100:.1f}% of all transactions)")
    print(f"Volume: ${small_tx_volume:,.2f} ({(small_tx_volume/total_volume)*100:.1f}% of total volume)")
    print(f"Fees: ${small_tx_fees:,.2f} ({(small_tx_fees/total_fees)*100:.1f}% of total fees)")
    print(f"Effective Rate: {(small_tx_fees/small_tx_volume)*100:.2f}%")

    # Calculate potential savings from batch processing
    fixed_fee_impact = small_tx_count * 0.30
    print(f"\nFixed Fee Impact: ${fixed_fee_impact:,.2f}")
    print(f"Potential savings from batching/minimum order: ${fixed_fee_impact * 0.5:,.2f} - ${fixed_fee_impact * 0.75:,.2f}")

Opportunity 3: Currency Conversion Costs

If you're accepting payments in multiple currencies, Stripe charges 1% for currency conversion. Analyze if offering local currency is worth this cost:

# Group by currency
currency_analysis = defaultdict(lambda: {'volume': 0, 'fees': 0, 'count': 0})

for transaction in fee_data:
    currency = transaction.get('currency', 'usd').upper()
    currency_analysis[currency]['volume'] += transaction['amount']
    currency_analysis[currency]['fees'] += transaction['fee']
    currency_analysis[currency]['count'] += 1

print("\nCurrency Analysis:")
for currency, stats in sorted(currency_analysis.items(), key=lambda x: x[1]['volume'], reverse=True):
    effective_rate = (stats['fees'] / stats['volume']) * 100
    print(f"{currency}: ${stats['volume']:,.2f} volume, {effective_rate:.3f}% effective rate")

Step 5: Implement Cost Reduction Strategies

Based on your analysis, implement these proven strategies to reduce Stripe fees:

Strategy 1: Negotiate Custom Pricing

If you're processing over $80,000/month, you likely qualify for custom pricing. Use your analysis data to negotiate:

• Show your current volume and projected growth
• Demonstrate consistent, quality transactions (low chargeback rate)
• Request reduced percentage rates or fixed fees
• Negotiate lower international or AmEx rates

Strategy 2: Optimize for Transaction Size

For businesses with many small transactions:

• Implement minimum order values to reduce fixed fee impact
• Offer incentives for larger purchases (bundle discounts)
• Consider subscription models to reduce transaction frequency
• Batch small recurring charges where appropriate

Strategy 3: Smart Payment Method Routing

Consider implementing payment method steering:

• Offer slight discounts for lower-cost payment methods (ACH transfers)
• For B2B transactions, encourage wire transfers or ACH for large amounts
• Use Stripe's payment method recommendations for international customers

Strategy 4: Reduce International Card Usage

If international fees are significant:

• Set up local entities in high-volume countries
• Use Stripe's local payment methods (iDEAL, SEPA, etc.) where available
• Consider region-specific payment processors for major markets

For a comprehensive analysis of your specific situation and automated optimization recommendations, use the MCP Analytics Stripe Fee Optimization Service.