Les API SERP facturent de quatre manières fondamentalement différentes : par recherche (SerpAPI), par packs de crédits avec expiration (Serper.dev), au tarif fixe par crédit (Scavio), et par niveaux file d'attente vs temps réel (DataForSEO). Le modèle de facturation que vous choisissez détermine si votre coût évolue linéairement avec l'utilisation ou vous pénalise pendant les mois d'inactivité. Ce tutoriel construit un calculateur de coût qui prend votre volume de requêtes mensuelles, votre tolérance à la latence et vos besoins en plateformes, puis affiche l'option la moins chère avec des montants exacts en dollars.
Prérequis
- Python 3.8+ ou Node.js 18+
- Compréhension de base des niveaux de tarification des API SERP
- Votre volume de requêtes mensuelles estimé
Parcours
Étape 1: Définir les modèles de tarification comme des données structurées
Encoder les niveaux de tarification, les coûts par requête et les contraintes de chaque API dans une structure de données que votre calculateur peut évaluer.
Python
import json
PRICING_MODELS = {
'scavio': {
'model': 'per_credit',
'per_query': 0.005,
'plans': [
{'name': 'Free', 'monthly': 0, 'credits': 250},
{'name': 'Project', 'monthly': 30, 'credits': 7000},
{'name': 'Bootstrap', 'monthly': 100, 'credits': 28000},
{'name': 'Startup', 'monthly': 250, 'credits': 85000},
{'name': 'Growth', 'monthly': 500, 'credits': 200000},
],
'overage': 0.005,
'platforms': ['google', 'amazon', 'youtube', 'walmart', 'reddit', 'tiktok'],
},
'dataforseo': {
'model': 'queue_tiers',
'tiers': [
{'name': 'Standard Queue', 'per_query': 0.0006, 'latency_min': 5},
{'name': 'Priority Queue', 'per_query': 0.0012, 'latency_min': 1},
{'name': 'Live', 'per_query': 0.002, 'latency_min': 0},
],
'min_deposit': 50,
'platforms': ['google'],
},
'serper': {
'model': 'credit_packs',
'packs': [
{'credits': 50000, 'price': 50, 'per_query': 0.001},
{'credits': 500000, 'price': 375, 'per_query': 0.00075},
],
'expiry_months': 6,
'platforms': ['google'],
},
'serpapi': {
'model': 'subscription',
'plans': [
{'name': 'Free', 'monthly': 0, 'searches': 100},
{'name': 'Starter', 'monthly': 25, 'searches': 1000},
{'name': 'Business', 'monthly': 275, 'searches': 30000},
],
'platforms': ['google', 'bing', 'yahoo', 'baidu'],
},
}Étape 2: Construire le moteur de calcul des coûts
Pour chaque API, calculer le coût mensuel pour un volume de requêtes donné. Gérer la sélection du plan, le dépassement, le dimensionnement des packs et l'optimisation des niveaux de file d'attente.
Python
def calculate_cost(api_name, monthly_queries, need_realtime=True):
api = PRICING_MODELS[api_name]
model = api['model']
if model == 'per_credit':
best_cost = float('inf')
best_plan = None
for plan in api['plans']:
if monthly_queries <= plan['credits']:
cost = plan['monthly']
else:
cost = plan['monthly'] + (monthly_queries - plan['credits']) * api['overage']
if cost < best_cost:
best_cost = cost
best_plan = plan['name']
return {'api': api_name, 'plan': best_plan, 'monthly_cost': round(best_cost, 2)}
elif model == 'queue_tiers':
tier = api['tiers'][0] if not need_realtime else api['tiers'][-1]
cost = max(monthly_queries * tier['per_query'], api['min_deposit'])
return {'api': api_name, 'plan': tier['name'], 'monthly_cost': round(cost, 2)}
elif model == 'credit_packs':
best_pack = api['packs'][0]
for pack in api['packs']:
if monthly_queries * api['expiry_months'] <= pack['credits']:
best_pack = pack
break
monthly_cost = best_pack['price'] / api['expiry_months']
return {'api': api_name, 'plan': f"{best_pack['credits']:,} pack", 'monthly_cost': round(monthly_cost, 2)}
elif model == 'subscription':
best_plan = api['plans'][-1]
for plan in api['plans']:
if monthly_queries <= plan['searches']:
best_plan = plan
break
return {'api': api_name, 'plan': best_plan['name'], 'monthly_cost': best_plan['monthly']}Étape 3: Comparer toutes les API et les classer par coût
Exécuter le calculateur sur toutes les API pour votre volume et produire une comparaison classée.
Python
def compare_all(monthly_queries, need_realtime=True):
results = []
for api_name in PRICING_MODELS:
result = calculate_cost(api_name, monthly_queries, need_realtime)
result['per_query'] = round(result['monthly_cost'] / max(monthly_queries, 1), 5)
results.append(result)
results.sort(key=lambda x: x['monthly_cost'])
print(f'Cost comparison for {monthly_queries:,} queries/month (realtime={need_realtime}):')
for i, r in enumerate(results):
marker = ' << CHEAPEST' if i == 0 else ''
print(f" {r['api']:12} | {r['plan']:20} | ${r['monthly_cost']:>8.2f}/mo{marker}")
return results
compare_all(5000, need_realtime=True)
compare_all(50000, need_realtime=False)Étape 4: Valider avec un appel de test en direct à l'API
Exécuter une requête de test contre l'API Scavio pour confirmer qu'un crédit équivaut à une requête, quelle que soit la plateforme.
Python
import os, requests
API_KEY = os.environ['SCAVIO_API_KEY']
def test_pricing():
for platform in ['google', 'amazon', 'youtube']:
body = {'query': 'test', 'platform': platform, 'country_code': 'us'}
if platform == 'amazon': body['marketplace'] = 'US'
resp = requests.post('https://api.scavio.dev/api/v1/search',
headers={'x-api-key': API_KEY, 'Content-Type': 'application/json'}, json=body)
print(f'{platform}: {resp.status_code}, {len(resp.json().get("organic_results", resp.json().get("products", [])))} results')
print('Total: 3 credits ($0.015)')
test_pricing()Exemple Python
Python
import os, requests
API_KEY = os.environ['SCAVIO_API_KEY']
H = {'x-api-key': API_KEY, 'Content-Type': 'application/json'}
PRICING = {
'scavio': lambda q: min(p['mo'] + max(0, q - p['cr']) * 0.005
for p in [{'mo': 0, 'cr': 250}, {'mo': 30, 'cr': 7000}, {'mo': 100, 'cr': 28000}]),
'dataforseo_queue': lambda q: max(q * 0.0006, 50),
'serper': lambda q: 50 / 6 if q * 6 <= 50000 else 375 / 6,
'serpapi': lambda q: 0 if q <= 100 else 25 if q <= 1000 else 275,
}
def compare(queries):
costs = {k: round(v(queries), 2) for k, v in PRICING.items()}
for k, v in sorted(costs.items(), key=lambda x: x[1]):
print(f'{k:20}: ${v:.2f}/mo')
compare(5000)
compare(50000)Exemple JavaScript
JavaScript
const PRICING = {
scavio: (q) => Math.min(
...[{ mo: 0, cr: 250 }, { mo: 30, cr: 7000 }, { mo: 100, cr: 28000 }]
.map(p => p.mo + Math.max(0, q - p.cr) * 0.005)
),
dataforseo_queue: (q) => Math.max(q * 0.0006, 50),
serper: (q) => q * 6 <= 50000 ? 50 / 6 : 375 / 6,
serpapi: (q) => q <= 100 ? 0 : q <= 1000 ? 25 : 275,
};
function compare(queries) {
console.log(`--- ${queries.toLocaleString()} queries/mo ---`);
Object.entries(PRICING)
.map(([k, v]) => ({ api: k, cost: Math.round(v(queries) * 100) / 100 }))
.sort((a, b) => a.cost - b.cost)
.forEach(c => console.log(` ${c.api.padEnd(20)} $${c.cost.toFixed(2)}/mo`));
}
compare(5000);
compare(50000);Sortie attendue
JSON
Cost comparison for 5,000 queries/month (realtime=True):
serper | 50,000 pack | $8.33/mo << CHEAPEST
scavio | Project | $30.00/mo
dataforseo | Live | $50.00/mo
serpapi | Business | $275.00/mo
Cost comparison for 50,000 queries/month (realtime=False):
dataforseo | Standard Queue | $50.00/mo << CHEAPEST
serper | 500,000 pack | $62.50/mo
scavio | Growth | $500.00/mo
serpapi | Business | $275.00/mo