Cómo raspar TikTok para obtener información de video?

TikTok es una de las plataformas de redes sociales líderes con tráfico masivo. ¡Solo imagina cuántos datos valiosos puede proporcionar TikTok!

En este artículo, explicaremos cómo raspar información de video de TikTok. Además, demostraremos cómo raspar estos datos a través de la API oculta de TikTok o conjuntos de datos JSON incrustados. ¡Empecemos!

¿Por qué raspar TikTok?

TikTok cuenta con una enorme interacción social, lo que permite recopilar diversas ideas para diferentes casos de uso:

Análisis de tendencias

Las tendencias en TikTok cambian rápidamente, lo que dificulta mantenerse al día con las últimas preferencias de los usuarios. El raspado de TikTok captura eficazmente estos cambios de tendencia y su impacto, permitiendo mejorar las estrategias de marketing alineadas con los intereses del usuario.

Generación de leads

El raspado de datos de TikTok permite a las empresas identificar oportunidades de marketing y nuevos clientes. Esto se puede lograr identificando a los influencers cuyas características demográficas de seguidores coinciden con los sectores empresariales relevantes.

Análisis de sentimiento

El raspado web de TikTok sirve como una excelente fuente para recopilar datos de texto de los comentarios, que se pueden analizar a través de modelos de sentimiento para recopilar opiniones sobre temas específicos.

Desafíos del raspado de TikTok

El raspado de TikTok se refiere al proceso de extracción de datos públicamente disponibles de TikTok. Si bien puede involucrar actividades manuales y automatizadas, suele ser un proceso automatizado ejecutado por rastreadores web o scripts personalizados que interactúan con la API (Interfaz de programación de aplicaciones) de TikTok.

Los datos pueden incluir varios tipos de información, como:

1. Perfiles de usuario: Información sobre los usuarios de TikTok, incluidos nombres de perfil, biografías y recuentos de seguidores.
2. Datos demográficos: Datos relacionados con las características del usuario, como edad, sexo, ubicación e intereses.
3. Videos: Videos cortos publicados por los usuarios, incluidos subtítulos, me gusta, comentarios, compartidos y vistas.
4. Hashtags: Palabras clave o frases utilizadas para categorizar el contenido de TikTok.
5. Comentarios: Respuestas de texto enviadas por los usuarios, incluido el contenido de texto, las marcas de tiempo y el recuento de me gusta.
6. Métricas de participación: Información sobre cómo los usuarios interactúan con el contenido (me gusta, comentarios, compartidos, vistas).
7. Tendencias: Datos sobre temas, temas o estilos populares en TikTok.

¿Cómo construir tu raspador de TikTok?

¡Simplifiquemos las cosas! Ahora comenzamos formalmente el proceso paso a paso de raspado de datos de video de TikTok. ¡Es hora de experimentar el tremendo valor que TikTok tiene para ofrecer!

Antes de comenzar el proceso de raspado real, examinemos primero juntos la estructura del contenido de video de TikTok. Esto nos permitirá localizar más eficientemente la información requerida y completar la extracción de datos de una manera más sencilla.

¿Qué datos podemos raspar de los videos?

• URL del video
• Descripción del video
• Nombre de la música
• Fecha de lanzamiento
• Etiquetas
• Vistas
• Recuento de me gusta
• Recuento de comentarios
• Recuento de compartidos
• Recuento de marcadores

Análisis de la página de video

Para que el raspado de datos sea más intuitivo, analizaremos el siguiente video como referencia: https://www.tiktok.com/@petervufriends/video/7476546872253893934.

Protegemos firmemente la privacidad del sitio web. Todos los datos de este blog son públicos y solo se utilizan como demostración del proceso de rastreo. No guardamos ninguna información ni datos.

¿Cómo localizar los datos que necesitamos?

¡Profundicemos en la estructura HTML! Esto es lo que necesitamos extraer de este video:

Recuento de vistas

El recuento de vistas generalmente se muestra de manera prominente en la página del video. Simplemente abra las herramientas del desarrollador y ubique la etiqueta relevante:

<strong data-e2e="video-views" class="video-count css-dirst9-StrongVideoCount e148ts222">281.4K</strong>

Descripción y etiquetas del video

Como observamos inicialmente, la descripción y las etiquetas del video suelen aparecer en la misma sección. Sin embargo, algunos videos pueden no tener descripciones o etiquetas.

• La descripción del video está dentro de un <span> con una clase única: css-j2a19r-SpanText.
• Las etiquetas de video son separadas pero comparten el mismo atributo: data-e2e="search-common-link".

Título de la música

Fecha de carga

La fecha está aislada como el último <span> dentro de un elemento principal que contiene el atributo: data-e2e="browser-nickname".

Recuento de me gusta, comentarios y marcadores

Estas métricas suelen aparecer juntas, y puedes encontrarlas bajo la misma colección:

Para simplificar tu proceso de raspado, aquí tienes un resumen de los selectores esenciales:

• URL del video: <meta property="og:url">
• Descripción del video: ['span.css-j2a19r-SpanText']
• Título de la música: ['.css-pvx3oa-DivMusicText']
• Fecha de carga: ['span[data-e2e="browser-nickname"] span:last-child']
• Etiquetas: [data-e2e="search-common-link"]
• Recuento de vistas: [data-e2e="video-views"]
• Recuento de me gusta: [data-e2e="like-count"]
• Recuento de comentarios: [data-e2e="comment-count"]
• Recuento de compartidos: [data-e2e="share-count"]
• Recuento de marcadores: [data-e2e="undefined-count"]

¡Felicitaciones! Ahora entiendes completamente cómo localizar los datos necesarios. A continuación, ¡construyamos oficialmente el raspador!

Código de raspado completo

Omitiendo explicaciones innecesarias, aquí está el código de raspado listo para usar para una implementación inmediata:

from playwright.async_api import async_playwright
import asyncio, random, json, logging, time, os, yt_dlp
from urllib.parse import urlparse

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('tiktok_scraper.log'),
        logging.StreamHandler()
    ]
)

class TikTokScraper:
    def __init__(self):
        self.DOWNLOAD_VIDEO = True
        self.SAVE_DIR = "downloaded_videos"
        self.USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
        self.VIEWPORT = {'width': 1280, 'height': 720}
        self.TIMEOUT = 300  # 5 minute timeout

    async def random_sleep(self, min_seconds=1, max_seconds=3):
        """Random Delay"""
        delay = random.uniform(min_seconds, max_seconds)
        logging.info(f"Sleeping for {delay:.2f} seconds...")
        await asyncio.sleep(delay)

    async def handle_captcha(self, page):
        """Handling verification codes"""
        try:
            captcha_dialog = page.locator('div[role="dialog"]')
            if await captcha_dialog.count() > 0 and await captcha_dialog.is_visible():
                logging.warning("CAPTCHA detected. Please solve it manually.")
                await page.wait_for_selector('div[role="dialog"]', state='detached', timeout=self.TIMEOUT*1000)
                logging.info("CAPTCHA solved. Resuming...")
                await self.random_sleep(0.5, 1)
        except Exception as e:
            logging.error(f"Error handling CAPTCHA: {str(e)}")

    async def extract_video_info(self, page, video_url):
        """Extract video details"""
        logging.info(f"Extracting info from: {video_url}")
        
        try:
            await page.goto(video_url, wait_until="networkidle")
            await self.random_sleep(2, 4)
            await self.handle_captcha(page)

            # Waiting for key elements to load
            await page.wait_for_selector('[data-e2e="like-count"]', timeout=10000)
            
            video_info = await page.evaluate("""() => {
                const getTextContent = (selectors) => {
                    for (let selector of selectors) {
                        const element = document.querySelector(selector);
                        if (element && element.textContent.trim()) {
                            return element.textContent.trim();
                        }
                    }
                    return 'N/A';
                };

                const getTags = () => {
                    const tagElements = document.querySelectorAll('a[data-e2e="search-common-link"]');
                    return Array.from(tagElements).map(el => el.textContent.trim());
                };

                return {
                    likes: getTextContent(['[data-e2e="like-count"]', '[data-e2e="browse-like-count"]']),
                    comments: getTextContent(['[data-e2e="comment-count"]', '[data-e2e="browse-comment-count"]']),
                    shares: getTextContent(['[data-e2e="share-count"]']),
                    bookmarks: getTextContent(['[data-e2e="undefined-count"]']),
                    views: getTextContent(['[data-e2e="video-views"]']),
                    description: getTextContent(['span.css-j2a19r-SpanText']),
                    musicTitle: getTextContent(['.css-pvx3oa-DivMusicText']),
                    date: getTextContent(['span[data-e2e="browser-nickname"] span:last-child']),
                    author: getTextContent(['a[data-e2e="browser-username"]']),
                    tags: getTags(),
                    videoUrl: window.location.href
                };
            }""")

            logging.info(f"Successfully extracted info for: {video_url}")
            return video_info

        except Exception as e:
            logging.error(f"Failed to extract info from {video_url}: {str(e)}")
            return None

    def download_video(self, video_url):
        """Download Video"""
        if not os.path.exists(self.SAVE_DIR):
            os.makedirs(self.SAVE_DIR)

        ydl_opts = {
            'outtmpl': os.path.join(self.SAVE_DIR, '%(id)s.%(ext)s'),
            'format': 'best',
            'quiet': False,
            'no_warnings': False,
            'ignoreerrors': True
        }

        try:
            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                info = ydl.extract_info(video_url, download=True)
                filename = ydl.prepare_filename(info)
                logging.info(f"Video successfully downloaded: {filename}")
                return filename
        except Exception as e:
            logging.error(f"Error downloading video: {str(e)}")
            return None

    async def scrape_single_video(self, video_url):
        """Scrape the single short"""
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=False)
            context = await browser.new_context(
                viewport=self.VIEWPORT,
                user_agent=self.USER_AGENT,
            )
            
            page = await context.new_page()
            result = {}

            try:
                # Extract shorts information
                video_info = await self.extract_video_info(page, video_url)
                if not video_info:
                    raise Exception("Failed to extract video info")

                result.update(video_info)

                # Download TikTok shorts
                if self.DOWNLOAD_VIDEO:
                    filename = self.download_video(video_url)
                    if filename:
                        result['local_path'] = filename

            except Exception as e:
                logging.error(f"Error scraping video: {str(e)}")
            finally:
                await browser.close()
            
            return result

    def save_results(self, data, filename="tiktok_video_data.json"):
        """Save the results to a JSON file"""
        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        logging.info(f"Results saved to {filename}")

async def main():
    # Initialize the crawler
    scraper = TikTokScraper()
    
    # Target TikTok short's URL
    video_url = "https://www.tiktok.com/@petervufriends/video/7476546872253893934" # Just as an reference
    
    # scrape the short
    video_data = await scraper.scrape_single_video(video_url)
    
    # save the scraping result
    if video_data:
        scraper.save_results(video_data)
        logging.info("\nScraping completed. Results:")
        for key, value in video_data.items():
            logging.info(f"{key}: {value}")
    else:
        logging.error("Failed to scrape video data")

if __name__ == "__main__":
    asyncio.run(main())

Resultado del raspado

Obviamente, necesitamos programación y medidas complejas: establecer retrasos, omitir CAPTCHA, etc. para lograr el rastreo de datos. Entonces, ¿cómo obtener rápidamente datos de TikTok? ¡La potente API de raspado de terceros es tu mejor opción!

API de raspado: recopila datos de TikTok fácilmente

¿Por qué usar una API para recuperar detalles del producto de Walmart?

1. Mayor eficiencia

La búsqueda manual de datos de productos es lenta y propensa a errores. La API permite la recuperación automática de la información del producto de Walmart, asegurando una recopilación de datos rápida y consistente.

2. Datos precisos y en tiempo real

La API Scrapeless extrae datos directamente de las páginas de productos de Walmart, asegurando que la información recuperada esté actualizada y sea precisa. Esto evita errores causados por la entrada manual retrasada o fuentes desactualizadas.

3. Aplicable a varios escenarios comerciales

• Monitoreo de precios: Compare los precios de la competencia y ajuste las estrategias de precios.
• Seguimiento de inventario: Verifique la disponibilidad del producto para optimizar la gestión de la cadena de suministro.
• Análisis de revisiones: Analice los comentarios de los clientes para mejorar los productos y servicios.
• Investigación de mercado: Identifique productos populares y tome decisiones comerciales informadas.

¿Qué hace TikTok Scraper?

Este raspador de datos de TikTok es una poderosa API no oficial de TikTok que te proporciona datos de TikTok a gran escala para tus propios proyectos de datos, informes comerciales y como base para nuevas aplicaciones. Con este mejor raspador de TikTok, puedes obtener:

• Todos los resultados del hashtag seleccionado, incluidos los detalles: videos populares, marcas de tiempo, vistas, compartidos, comentarios y número de videos, etc.
• Todas las publicaciones del perfil de usuario seleccionado, incluidos los detalles: nombre, apodo, ID, biografía, seguidores/seguidos, reproducciones, compartidos y comentarios, etc.
• Publicaciones de videos individuales con URL de videos específicos.
• Datos relacionados con videos y música.

Raspado de datos de TikTok usando API

Paso 1. Crea tu token de API

Para comenzar, deberás obtener tu clave de API desde el Panel de Scrapeless:

• Inicia sesión en el Panel de Scrapeless.
• Navega a Gestión de claves API.
• Haz clic en Crear para generar tu clave API única.
• Una vez creada, simplemente haz clic en la clave API para copiarla.

Paso 2. Ingresa a la API de TikTok

• Haz clic en API de raspado en Para datos
• Encuentra TikTok e ingresa

Paso 3. Configuración de parámetros de solicitud

El actor de TikTok actualmente tiene dos escenarios de raspado:

• Información de búsqueda de TikTok: Raspa los resultados de búsqueda de videos para palabras clave específicas.
• Información del usuario de TikTok: Raspa la información del perfil de un usuario específico.

Habrá diferentes solicitudes de acción en cada escenario. Puedes hacer clic en la flecha plegable para encontrar la información de datos que necesitas raspar con precisión. Toma la información de búsqueda de TikTok como ejemplo:

¿Estás listo? Después de comprender la información básica, ¡podemos comenzar oficialmente a raspar datos!

• Ahora solo necesitas completar la configuración de parámetros en el lado izquierdo del actor de acuerdo con tus necesidades

• Después de confirmar que todo es correcto, simplemente haz clic en Iniciar raspado para obtener fácilmente los resultados del raspado.

¡Obtén los datos del video de TikTok ahora!

A partir de ahora, deberías tener un raspador que funcione y que pueda extraer datos de TikTok. Este es un gran comienzo, pero definitivamente puedes ir más allá.

Si estás analizando tendencias de TikTok, realizando investigaciones o satisfaciendo tu curiosidad por los datos, ahora tienes herramientas poderosas para explorar el almacén de datos de TikTok sin muchos dolores de cabeza.

La API de raspado Scrapeless te ahorra la molestia de un código complejo. Simplemente configura algunos parámetros para obtener los datos más recientes al instante.

¡Comienza una prueba gratuita ahora!