La surveillance de marque multiplateforme suit la présence de votre marque dans les résultats de recherche Google, les vidéos TikTok, les listes de produits Amazon et le contenu YouTube via un pipeline unique et unifié. Au lieu de jongler avec quatre API distinctes ayant des schémas d'authentification, des limites de débit et des formats de réponse différents, vous pouvez utiliser l'API Scavio Search pour Google, Amazon et YouTube ainsi que l'API Scavio TikTok pour TikTok — deux points d'accès couvrant quatre plateformes. Ce tutoriel construit un pipeline de surveillance quotidienne qui produit un rapport unifié sur la santé de la marque avec le nombre de mentions, les signaux de sentiment et les benchmarks concurrentiels.
Prérequis
- Python 3.10+ installé
- bibliothèque requests installée
- Une clé API Scavio provenant de scavio.dev
- Nom de la marque et 1 à 2 noms de concurrents à surveiller
Parcours
Étape 1: Configurer les clients API partagés
Créez deux fonctions d'assistance : une pour l'API Search (Google, Amazon, YouTube) et une pour l'API TikTok. Les deux utilisent la même clé API mais des schémas d'authentification différents.
Python
import requests, os
API_KEY = os.environ['SCAVIO_API_KEY']
SEARCH_URL = 'https://api.scavio.dev/api/v1/search'
TIKTOK_URL = 'https://api.scavio.dev/api/v1/tiktok'
def search_api(body: dict) -> dict:
resp = requests.post(SEARCH_URL,
headers={'x-api-key': API_KEY, 'Content-Type': 'application/json'},
json=body)
resp.raise_for_status()
return resp.json()
def tiktok_api(endpoint: str, body: dict) -> dict:
resp = requests.post(f'{TIKTOK_URL}/{endpoint}',
headers={'Authorization': f'Bearer {API_KEY}',
'Content-Type': 'application/json'},
json=body)
resp.raise_for_status()
return resp.json()Étape 2: Surveiller les mentions sur Google, Amazon et YouTube
Recherchez les mentions de la marque sur chaque plateforme. Comptez combien de fois votre marque apparaît dans les résultats organiques, les listes Amazon et les vidéos YouTube.
Python
def monitor_google(brand: str) -> dict:
data = search_api({'query': f'"{brand}"', 'country_code': 'us'})
organic = data.get('organic_results', [])
return {'platform': 'google', 'mentions': len(organic),
'top_result': organic[0]['title'] if organic else None}
def monitor_amazon(brand: str) -> dict:
data = search_api({'platform': 'amazon', 'query': brand, 'marketplace': 'US'})
products = data.get('products', [])
return {'platform': 'amazon', 'listings': len(products),
'avg_rating': sum(p.get('rating', 0) for p in products) / max(len(products), 1)}
def monitor_youtube(brand: str) -> dict:
data = search_api({'platform': 'youtube', 'query': brand})
videos = data.get('videos', [])
return {'platform': 'youtube', 'videos': len(videos),
'top_video': videos[0].get('title') if videos else None}
for fn in [monitor_google, monitor_amazon, monitor_youtube]:
result = fn('yourBrand')
print(result)Étape 3: Surveiller les mentions TikTok et la présence de hashtags
Recherchez sur TikTok les mentions vidéo de la marque et vérifiez les statistiques du hashtag de la marque. Combinez les deux signaux pour un score de présence TikTok.
Python
def monitor_tiktok(brand: str) -> dict:
# Video mentions
search_data = tiktok_api('search/videos',
{'keyword': brand, 'count': 20, 'cursor': 0})['data']
video_count = len(search_data.get('videos', []))
total_plays = sum(v.get('stats', {}).get('playCount', 0)
for v in search_data.get('videos', []))
# Hashtag presence
try:
hashtag_data = tiktok_api('hashtag', {'hashtag': brand})['data']
hashtag_views = hashtag_data['stats']['view_count']
except Exception:
hashtag_views = 0
return {
'platform': 'tiktok',
'video_mentions': video_count,
'total_plays': total_plays,
'hashtag_views': hashtag_views
}
tiktok_stats = monitor_tiktok('yourBrand')
print(tiktok_stats)Étape 4: Construire le rapport quotidien unifié
Combinez toutes les données des plateformes en un seul rapport. Exécutez-le quotidiennement pour suivre la santé de la marque au fil du temps. Ajoutez des marques concurrentes pour benchmarker la part de voix.
Python
import json
from datetime import date
def brand_report(brands: list) -> dict:
report = {'date': date.today().isoformat(), 'brands': {}}
for brand in brands:
report['brands'][brand] = {
'google': monitor_google(brand),
'amazon': monitor_amazon(brand),
'youtube': monitor_youtube(brand),
'tiktok': monitor_tiktok(brand)
}
# Share of voice: total mentions across platforms
for brand in brands:
data = report['brands'][brand]
total = (data['google']['mentions'] + data['amazon']['listings'] +
data['youtube']['videos'] + data['tiktok']['video_mentions'])
data['total_mentions'] = total
grand_total = sum(b['total_mentions'] for b in report['brands'].values())
for brand in brands:
sov = report['brands'][brand]['total_mentions'] / max(grand_total, 1)
report['brands'][brand]['share_of_voice'] = round(sov * 100, 1)
with open(f'brand_monitor_{date.today()}.json', 'w') as f:
json.dump(report, f, indent=2)
return report
report = brand_report(['yourBrand', 'competitorA', 'competitorB'])
for brand, data in report['brands'].items():
print(f"{brand}: {data['total_mentions']} mentions, {data['share_of_voice']}% SoV")Étape 5: Estimer le coût mensuel de l'API
Calculez l'utilisation des crédits pour la surveillance quotidienne sur toutes les plateformes. Chaque appel API coûte 1 crédit à 0,005 $. Une exécution quotidienne pour 3 marques sur 4 plateformes utilise environ 15 à 20 crédits par jour.
Python
def estimate_monthly_cost(num_brands: int, runs_per_day: int = 1) -> dict:
# Per brand per run: 1 Google + 1 Amazon + 1 YouTube + 2 TikTok = 5 credits
credits_per_run = num_brands * 5
daily_credits = credits_per_run * runs_per_day
monthly_credits = daily_credits * 30
cost = monthly_credits * 0.005
return {
'brands': num_brands,
'daily_credits': daily_credits,
'monthly_credits': monthly_credits,
'monthly_cost': f'${cost:.2f}',
'recommended_plan': '$30/7K credits' if monthly_credits <= 7000
else '$100/28K credits' if monthly_credits <= 28000
else '$250/85K credits'
}
for n in [3, 10, 25]:
est = estimate_monthly_cost(n)
print(f"{est['brands']} brands: {est['monthly_credits']} credits/mo "
f"({est['monthly_cost']}), plan: {est['recommended_plan']}")Exemple Python
Python
import requests, os, json
from datetime import date
API_KEY = os.environ['SCAVIO_API_KEY']
SEARCH_URL = 'https://api.scavio.dev/api/v1/search'
TIKTOK_URL = 'https://api.scavio.dev/api/v1/tiktok'
def search_api(body):
return requests.post(SEARCH_URL,
headers={'x-api-key': API_KEY, 'Content-Type': 'application/json'},
json=body).json()
def tiktok_api(endpoint, body):
return requests.post(f'{TIKTOK_URL}/{endpoint}',
headers={'Authorization': f'Bearer {API_KEY}',
'Content-Type': 'application/json'},
json=body).json()
def monitor_brand(brand):
google = search_api({'query': f'"{brand}"', 'country_code': 'us'})
amazon = search_api({'platform': 'amazon', 'query': brand, 'marketplace': 'US'})
youtube = search_api({'platform': 'youtube', 'query': brand})
tiktok = tiktok_api('search/videos', {'keyword': brand, 'count': 20, 'cursor': 0})
return {
'google_mentions': len(google.get('organic_results', [])),
'amazon_listings': len(amazon.get('products', [])),
'youtube_videos': len(youtube.get('videos', [])),
'tiktok_videos': len(tiktok.get('data', {}).get('videos', [])),
}
brands = ['yourBrand', 'competitorA', 'competitorB']
report = {b: monitor_brand(b) for b in brands}
for brand, data in report.items():
total = sum(data.values())
print(f'{brand}: {total} total mentions across 4 platforms')
for k, v in data.items():
print(f' {k}: {v}')Exemple JavaScript
JavaScript
const API_KEY = process.env.SCAVIO_API_KEY;
const SEARCH_URL = 'https://api.scavio.dev/api/v1/search';
const TIKTOK_URL = 'https://api.scavio.dev/api/v1/tiktok';
async function searchApi(body) {
const r = await fetch(SEARCH_URL, {
method: 'POST',
headers: { 'x-api-key': API_KEY, 'Content-Type': 'application/json' },
body: JSON.stringify(body)
});
return r.json();
}
async function tiktokApi(endpoint, body) {
const r = await fetch(`${TIKTOK_URL}/${endpoint}`, {
method: 'POST',
headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
body: JSON.stringify(body)
});
return r.json();
}
async function monitorBrand(brand) {
const [google, amazon, youtube, tiktok] = await Promise.all([
searchApi({ query: `"${brand}"`, country_code: 'us' }),
searchApi({ platform: 'amazon', query: brand, marketplace: 'US' }),
searchApi({ platform: 'youtube', query: brand }),
tiktokApi('search/videos', { keyword: brand, count: 20, cursor: 0 })
]);
return {
google: (google.organic_results || []).length,
amazon: (amazon.products || []).length,
youtube: (youtube.videos || []).length,
tiktok: (tiktok.data?.videos || []).length
};
}
async function main() {
for (const brand of ['yourBrand', 'competitorA', 'competitorB']) {
const data = await monitorBrand(brand);
const total = Object.values(data).reduce((a, b) => a + b, 0);
console.log(`${brand}: ${total} mentions (G:${data.google} A:${data.amazon} Y:${data.youtube} T:${data.tiktok})`);
}
}
main().catch(console.error);Sortie attendue
JSON
{
"date": "2026-05-12",
"brands": {
"yourBrand": {
"google_mentions": 10,
"amazon_listings": 5,
"youtube_videos": 8,
"tiktok_videos": 14,
"total_mentions": 37,
"share_of_voice": 45.1
},
"competitorA": {
"total_mentions": 28,
"share_of_voice": 34.1
},
"competitorB": {
"total_mentions": 17,
"share_of_voice": 20.7
}
}
}
3 brands: 450 credits/mo ($2.25), plan: $30/7K credits
10 brands: 1500 credits/mo ($7.50), plan: $30/7K credits
25 brands: 3750 credits/mo ($18.75), plan: $30/7K credits