El monitoreo de marca multiplataforma rastrea la presencia de su marca en los resultados de búsqueda de Google, videos de TikTok, listados de productos de Amazon y contenido de YouTube en un único canal unificado. En lugar de hacer malabarismos con cuatro API separadas con diferentes esquemas de autenticación, límites de velocidad y formatos de respuesta, puede usar la API de búsqueda Scavio para Google, Amazon y YouTube y la API Scavio TikTok para TikTok: dos puntos finales que cubren cuatro plataformas. Este tutorial crea un proceso de monitoreo diario que genera un informe unificado sobre el estado de la marca con recuentos de menciones, señales de sentimiento y puntos de referencia de la competencia.
Requisitos previos
- Python 3.10+ instalado
- solicita biblioteca instalada
- Una clave API de Scavio de scavio.dev
- Nombre de la marca y 1 o 2 nombres de competidores para monitorear
Guia paso a paso
Paso 1: Configurar los clientes API compartidos
Cree dos funciones auxiliares: una para la API de búsqueda (Google, Amazon, YouTube) y otra para la API de TikTok. Ambos usan la misma clave API pero diferentes patrones de autenticación.
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()Paso 2: Monitorear las menciones de Google, Amazon y YouTube
Busque menciones de marca en cada plataforma. Cuente cuántas veces aparece su marca en resultados orgánicos, listados de Amazon y videos de 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)Paso 3: Monitorear las menciones de TikTok y la presencia de hashtags
Busque en TikTok menciones en videos de marcas y verifique las estadísticas del hashtag de la marca. Combine ambas señales para obtener una puntuación de presencia en 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)Paso 4: Cree el informe diario unificado
Combine todos los datos de la plataforma en un solo informe. Ejecute esto diariamente para realizar un seguimiento del estado de la marca a lo largo del tiempo. Agregue marcas de la competencia para comparar la participación de voz.
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")Paso 5: Estimar el costo mensual de API
Calcule el uso del crédito para el seguimiento diario en todas las plataformas. Cada llamada API cuesta 1 crédito a $0,005. Una ejecución diaria para 3 marcas en 4 plataformas utiliza aproximadamente entre 15 y 20 créditos por día.
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']}")Ejemplo en 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}')Ejemplo en 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);Salida esperada
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