Calcul du coût effectif par requête d'API SERP : il faut tenir compte du taux d'utilisation, des lacunes fonctionnelles qui imposent des contournements, du temps d'ingénierie passé sur les bizarreries d'intégration, et des frais de tokens LLM liés aux réponses verbeuses — pas seulement le prix affiché par requête. Ce tutoriel construit un modèle de coût qui révèle le vrai prix par requête pour toute API SERP, afin de pouvoir comparer objectivement et éviter les frais cachés qui gonflent votre facture.
Prérequis
- Données de facturation actuelles de l'API SERP ou détails de la page de tarification
- Python 3.9+ ou Node.js 18+
- Estimation du volume de requêtes mensuel et du taux horaire d'ingénierie
Parcours
Étape 1: Recueillir les données de prix brutes
Collectez le prix affiché, le quota de requêtes inclus, les tarifs de dépassement et tout engagement minimum pour chaque API que vous comparez. Notez également les fonctionnalités incluses (données structurées, panels de connaissances, fonctionnalités SERP) par rapport à celles nécessitant des appels supplémentaires.
providers = {
'provider_a': {
'plan_cost': 100,
'included_queries': 5000,
'overage_per_query': 0.025,
'has_structured_data': False,
'has_knowledge_panels': True,
'avg_response_tokens': 4200,
},
'scavio': {
'plan_cost': 100,
'included_queries': 28000, # $100/28K credits
'overage_per_query': 0.005,
'has_structured_data': True,
'has_knowledge_panels': True,
'avg_response_tokens': 1800,
},
}
monthly_queries = 15000
eng_hourly_rate = 75 # USDÉtape 2: Calculer le coût de base par requête
Calculez le coût de base par requête en tenant compte du taux d'utilisation. Si vous n'utilisez que 60 % de votre quota inclus, le prix effectif par requête est plus élevé que le prix affiché car vous payez pour la capacité inutilisée.
def base_cost_per_query(provider, monthly_queries):
included = provider['included_queries']
plan_cost = provider['plan_cost']
if monthly_queries <= included:
# Paying for unused queries
utilization = monthly_queries / included
effective = plan_cost / monthly_queries
else:
overage = monthly_queries - included
total_cost = plan_cost + (overage * provider['overage_per_query'])
effective = total_cost / monthly_queries
utilization = 1.0
return {
'effective_per_query': round(effective, 5),
'utilization': round(utilization * 100, 1),
'monthly_total': round(effective * monthly_queries, 2),
}Étape 3: Ajouter la surcharge liée aux lacunes fonctionnelles
Si un fournisseur ne dispose pas d'extraction de données structurées, vous aurez besoin de temps d'ingénierie supplémentaire ou d'appels API additionnels pour obtenir ces données. Estimez les heures d'ingénierie mensuelles consacrées aux contournements et ajoutez-les au coût.
def feature_gap_cost(provider, monthly_queries, eng_hourly_rate):
hours_per_month = 0
extra_queries = 0
if not provider['has_structured_data']:
# Estimate 4 hours/month building and maintaining parsing logic
hours_per_month += 4
# 10% of queries need a follow-up call to get structured data
extra_queries += int(monthly_queries * 0.10)
eng_cost = hours_per_month * eng_hourly_rate
extra_query_cost = extra_queries * provider['overage_per_query']
return {
'eng_hours': hours_per_month,
'eng_cost': eng_cost,
'extra_queries': extra_queries,
'extra_query_cost': extra_query_cost,
'total_gap_cost': eng_cost + extra_query_cost,
}Étape 4: Estimer les frais de tokens LLM
Si vous transmettez les résultats SERP à un LLM, les réponses verbeuses de l'API coûtent plus cher en tokens. Calculez la différence de coût mensuel de tokens en fonction de la taille moyenne des réponses. Au tarif typique de 3 $ par million de tokens pour l'entrée LLM, cela s'accumule rapidement à grande échelle.
def llm_token_cost(provider, monthly_queries, cost_per_million_tokens=3.0):
total_tokens = provider['avg_response_tokens'] * monthly_queries
cost = (total_tokens / 1_000_000) * cost_per_million_tokens
return {
'total_tokens': total_tokens,
'monthly_llm_cost': round(cost, 2),
'per_query_llm_cost': round(cost / monthly_queries, 6),
}Étape 5: Calculer le coût effectif total et comparer
Additionnez le coût de base, la surcharge liée aux lacunes fonctionnelles et les frais de tokens LLM pour obtenir le vrai coût effectif par requête. Affichez un tableau comparatif pour voir quel fournisseur est réellement le moins cher pour votre charge de travail.
print(f'Monthly volume: {monthly_queries:,} queries\n')
print(f'{"Provider":<15} {"Base":>8} {"Gaps":>8} {"LLM":>8} {"Total":>8} {"Per-Query":>10}')
print('-' * 65)
for name, p in providers.items():
base = base_cost_per_query(p, monthly_queries)
gaps = feature_gap_cost(p, monthly_queries, eng_hourly_rate)
llm = llm_token_cost(p, monthly_queries)
total = base['monthly_total'] + gaps['total_gap_cost'] + llm['monthly_llm_cost']
per_query = total / monthly_queries
print(f'{name:<15} ${base["monthly_total"]:>7.2f} ${gaps["total_gap_cost"]:>7.2f} ${llm["monthly_llm_cost"]:>7.2f} ${total:>7.2f} ${per_query:>9.5f}')Exemple Python
providers = {
'provider_a': {
'plan_cost': 100,
'included_queries': 5000,
'overage_per_query': 0.025,
'has_structured_data': False,
'has_knowledge_panels': True,
'avg_response_tokens': 4200,
},
'scavio': {
'plan_cost': 100,
'included_queries': 28000,
'overage_per_query': 0.005,
'has_structured_data': True,
'has_knowledge_panels': True,
'avg_response_tokens': 1800,
},
}
monthly_queries = 15000
eng_hourly_rate = 75
def base_cost_per_query(provider, monthly_queries):
included = provider['included_queries']
plan_cost = provider['plan_cost']
if monthly_queries <= included:
effective = plan_cost / monthly_queries
else:
overage = monthly_queries - included
total_cost = plan_cost + (overage * provider['overage_per_query'])
effective = total_cost / monthly_queries
return round(effective * monthly_queries, 2)
def feature_gap_cost(provider, monthly_queries, eng_rate):
hours = 0 if provider['has_structured_data'] else 4
extra_queries = 0 if provider['has_structured_data'] else int(monthly_queries * 0.10)
return hours * eng_rate + extra_queries * provider['overage_per_query']
def llm_token_cost(provider, monthly_queries):
tokens = provider['avg_response_tokens'] * monthly_queries
return round((tokens / 1_000_000) * 3.0, 2)
print(f'Monthly volume: {monthly_queries:,} queries')
print(f'{"Provider":<15} {"Base":>8} {"Gaps":>8} {"LLM":>8} {"Total":>8} {"Per-Query":>10}')
print('-' * 65)
for name, p in providers.items():
base = base_cost_per_query(p, monthly_queries)
gaps = feature_gap_cost(p, monthly_queries, eng_hourly_rate)
llm = llm_token_cost(p, monthly_queries)
total = base + gaps + llm
per_q = total / monthly_queries
print(f'{name:<15} ${base:>7.2f} ${gaps:>7.2f} ${llm:>7.2f} ${total:>7.2f} ${per_q:>9.5f}')Exemple JavaScript
const providers = {
provider_a: {
planCost: 100,
includedQueries: 5000,
overagePerQuery: 0.025,
hasStructuredData: false,
avgResponseTokens: 4200,
},
scavio: {
planCost: 100,
includedQueries: 28000,
overagePerQuery: 0.005,
hasStructuredData: true,
avgResponseTokens: 1800,
},
};
const monthlyQueries = 15000;
const engHourlyRate = 75;
function baseCost(p, queries) {
if (queries <= p.includedQueries) return p.planCost;
const overage = queries - p.includedQueries;
return p.planCost + overage * p.overagePerQuery;
}
function featureGapCost(p, queries, engRate) {
if (p.hasStructuredData) return 0;
const engCost = 4 * engRate;
const extraQueries = Math.floor(queries * 0.1) * p.overagePerQuery;
return engCost + extraQueries;
}
function llmTokenCost(p, queries) {
const tokens = p.avgResponseTokens * queries;
return (tokens / 1_000_000) * 3.0;
}
console.log(`Monthly volume: ${monthlyQueries.toLocaleString()} queries`);
console.log('Provider Base Gaps LLM Total Per-Query');
console.log('-'.repeat(60));
for (const [name, p] of Object.entries(providers)) {
const base = baseCost(p, monthlyQueries);
const gaps = featureGapCost(p, monthlyQueries, engHourlyRate);
const llm = llmTokenCost(p, monthlyQueries);
const total = base + gaps + llm;
const perQ = total / monthlyQueries;
console.log(
`${name.padEnd(15)} $${base.toFixed(2).padStart(7)} $${gaps.toFixed(2).padStart(7)} $${llm.toFixed(2).padStart(7)} $${total.toFixed(2).padStart(7)} $${perQ.toFixed(5).padStart(9)}`
);
}Sortie attendue
Monthly volume: 15,000 queries
Provider Base Gaps LLM Total Per-Query
-----------------------------------------------------------------
provider_a $350.00 $337.50 $189.00 $876.50 $0.05843
scavio $100.00 $0.00 $81.00 $181.00 $0.01207