Scrape TikTok Like a Pro: Step-by-Step Methods, Tools, and Tips

import asyncio
import json
from playwright.async_api import async_playwright

async def scrape_tiktok_profile(username: str, proxy_host: str, proxy_port: int, proxy_username: str, proxy_password: str):
    """Scrape TikTok profile data using proxy"""
    
    async with async_playwright() as p:
        browser = await p.firefox.launch(
            headless=True,
            proxy={'server': f'http://{proxy_host}:{proxy_port}', 'username': proxy_username, 'password': proxy_password}
        )
        
        context = await browser.new_context(
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
        )
        await context.add_init_script("Object.defineProperty(navigator, 'webdriver', { get: () => undefined });")
        page = await context.new_page()
        
        try:
            await page.goto(f"https://www.tiktok.com/@{username}", timeout=20000)
            await page.wait_for_timeout(3000)
            
            # Extract from JSON
            user_info, video_count = {}, 0
            json_script = await page.query_selector('script#__UNIVERSAL_DATA_FOR_REHYDRATION__')
            
            if json_script:
                try:
                    data = json.loads(await json_script.text_content())
                    # Try multiple JSON paths
                    for path in [['__DEFAULT_SCOPE__', 'webapp.user-detail', 'userInfo'], ['default', 'UserModule', 'users']]:
                        current = data
                        for key in path:
                            current = current.get(key, {})
                        if current and 'user' in current:
                            user_info = current['user']
                            video_count = current.get('stats', {}).get('videoCount', 0)
                            break
                        elif current and 'uniqueId' in current:
                            user_info = current
                            break
                except:
                    pass
            
            # HTML fallback
            if not user_info:
                elem = await page.query_selector('[data-e2e="user-title"]')
                if elem:
                    text = await elem.text_content()
                    user_info = {'uniqueId': text.strip(), 'nickname': text.strip(), 'signature': '', 'verified': False}
            
            if not user_info:
                return {'error': 'Could not extract profile data'}
            
            # Extract stats from HTML
            stats = []
            for selector in ['strong[data-e2e]', '[data-e2e="number-strong"]', 'strong']:
                elements = await page.query_selector_all(selector)
                if len(elements) >= 3:
                    stats = [await elem.text_content() for elem in elements[:3]]
                    break
            
            # Clean bio
            bio = user_info.get('signature', '').replace('\n', ' | ').replace('\r', ' | ')
            
            return {
                'username': user_info.get('uniqueId', ''),
                'display_name': user_info.get('nickname', ''),
                'bio': bio,
                'followers': stats[1] if len(stats) > 1 else "0",
                'following': stats[0] if len(stats) > 0 else "0", 
                'likes': stats[2] if len(stats) > 2 else "0",
                'videos': video_count,
                'verified': user_info.get('verified', False)
            }
            
        except Exception as e:
            return {'error': str(e)}
        finally:
            await browser.close()


async def main():
    # Decodo proxy configuration
    result = await scrape_tiktok_profile(
        username='beccastravel',  # Example TikTok username – replace
        proxy_host='gate.decodo.com',
        proxy_port=7000,
        proxy_username='YOUR_USERNAME',  # Replace
        proxy_password='YOUR_PASSWORD'   # Replace
    )
    
    print(json.dumps(result, indent=2))


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

{
  "username": "beccastravel",
  "display_name": "Becca -A Brit in Aus\ud83c\udde6\ud83c\uddfa\ud83c\udf0a\ud83e\udebc",
  "bio": "Brit living in Australia \ud83c\udde6\ud83c\uddfa",
  "followers": "6580",
  "following": "1404",
  "likes": "2.5M",
  "videos": 1034,
  "verified": false
}

import jmespath
import asyncio
import json
from typing import List, Dict
from httpx import AsyncClient, Response
from parsel import Selector

async def create_client() -> AsyncClient:
    """Create HTTP client with proxy"""
    headers = {
        "Accept-Language": "en-US,en;q=0.9",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
        "Accept-Encoding": "gzip, deflate, br",
    }
    
    # Proxy configuration: replace with your credentials in this format: "protocol://username:password@host:port"
    proxy = "http://YOUR_USERNAME:[email protected]:7000"
    
    return AsyncClient(
        http2=True,
        headers=headers,
        proxy=proxy,
        timeout=30.0,
        follow_redirects=True
    )

def parse_video(response: Response) -> Dict:
    """Parse video data from response"""
    selector = Selector(response.text)
    
    # Try JSON extraction first
    try:
        json_data = selector.xpath("//script[@id='__UNIVERSAL_DATA_FOR_REHYDRATION__']/text()").get()
        if json_data:
            full_data = json.loads(json_data)
            video_data = full_data["__DEFAULT_SCOPE__"]["webapp.video-detail"]["itemInfo"]["itemStruct"]
            
            result = jmespath.search("""
            {
                id: id,
                description: desc,
                hashtags: textExtra[?hashtagName].hashtagName,
                author: {
                    username: author.uniqueId,
                    nickname: author.nickname,
                    verified: author.verified
                },
                stats: {
                    plays: stats.playCount,
                    likes: stats.diggCount,
                    comments: stats.commentCount,
                    shares: stats.shareCount,
                    bookmarks: stats.collectCount
                }
            }""", video_data)
            
            result['url'] = str(response.url)
            
            # Clean description
            if result.get('description'):
                result['description'] = result['description'].replace('\n', ' | ')
            
            return result
    except:
        pass
    
    # HTML fallback
    description = selector.xpath("//meta[@property='og:description']/@content").get() or ""
    
    return {
        'description': description.replace('\n', ' | '),
        'hashtags': [],
        'url': str(response.url),
        'stats': {'plays': 0, 'likes': 0, 'comments': 0, 'shares': 0, 'bookmarks': 0}
    }

async def scrape_tiktok_videos() -> List[Dict]:
    """Scrape videos"""
    
    # Example URLs – replace
    video_urls = [
        "https://www.tiktok.com/@kululagu/video/7447897941609630992",
        "https://www.tiktok.com/@reachyusuf/video/7507345573087890695",
        "https://www.tiktok.com/@yuji_beleza/video/7503491626569043223"
    ]
    
    client = await create_client()
    
    try:
        results = []
        
        for i, url in enumerate(video_urls):
            try:
                response = await client.get(url)
                
                if response.status_code != 200:
                    results.append({'error': f'HTTP {response.status_code}', 'url': url})
                    continue
                
                video_data = parse_video(response)
                
                if 'error' not in video_data and video_data.get('author'):
                    results.append(video_data)
                else:
                    results.append({'error': 'Failed to extract data', 'url': url})
                
                # Small delay between requests
                await asyncio.sleep(1)
                
            except Exception as e:
                results.append({'error': str(e), 'url': url})
        
        return results
        
    finally:
        await client.aclose()

async def main():
    """Main function"""
    videos = await scrape_tiktok_videos()
    
    for i, video in enumerate(videos, 1):
        if 'error' not in video and video.get('author'):
            author = video.get('author', {}).get('username', 'Unknown')
            desc = video.get('description', 'No description')
            stats = video.get('stats', {})
            
            # Ensure all stats are integers
            def safe_int(value):
                if value is None:
                    return 0
                try:
                    return int(value)
                except (ValueError, TypeError):
                    return 0
            
            likes = safe_int(stats.get('likes'))
            plays = safe_int(stats.get('plays'))
            comments = safe_int(stats.get('comments'))
            shares = safe_int(stats.get('shares'))
            bookmarks = safe_int(stats.get('bookmarks'))
            hashtags = video.get('hashtags', [])
            
            hashtag_text = f" #{' #'.join(hashtags)}" if hashtags else ""
            print(f"{i}. @{author}:")
            print(f"   {desc}{hashtag_text}")
            print(f"   {likes:,} likes, {plays:,} plays, {comments:,} comments")
            print(f"   {shares:,} shares, {bookmarks:,} bookmarks")
        else:
            print(f"{i}. Error: {video.get('error', 'Failed to extract data')}")
        
        # Add separator line between videos (except after the last one)
        if i < len(videos):
            print("-" * 50)

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

1. @kululagu:
   I dont like the third movie but ı wonder ıf ı will like it when ı grow older #beforesunrise #beforetrilogy #beforesunset #beforemidnight #ethanhawke #juliedelpy #fyp  #beforesunrise #beforetrilogy #beforesunset #beforemidnight #ethanhawke #juliedelpy #fyp
   218,900 likes, 923,000 plays, 503 comments
   8,939 shares, 37,206 bookmarks
--------------------------------------------------
2. @reachyusuf:
   what's yo favorite type of bread? Flour is a miracle right now. Currently a bag of flour costs $600 usd. My charity has been able to acquire 3000 bags thank God. $200 covers 1 bag of flour (25 kg) through my charity. If you can sponsor a family for a bag of flour please d0nate in the l1nk in b1o! Families are using macaroni to make bread because they cannot afford flour. Please spread the word and d0nate if you can!
   538,100 likes, 2,800,000 plays, 16,700 comments
   55,400 shares, 46,365 bookmarks
--------------------------------------------------
3. @yuji_beleza:
   African basketball players in Japan 🇯🇵🏀
   9,100,000 likes, 109,100,000 plays, 40,300 comments
   146,400 shares, 405,175 bookmarks

import asyncio
import re
from httpx import AsyncClient
from urllib.parse import urlencode

async def create_client():
    headers = {
        "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
        "accept-language": "en-US,en;q=0.9",
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
    }
    # Proxy configuration: replace with your credentials in this format: "protocol://username:password@host:port"
    proxy = "http://YOUR_USERNAME:[email protected]:7000"
    return AsyncClient(headers=headers, proxy=proxy, timeout=30.0)

async def scrape_tiktok_comments(video_url, max_comments=20):
    video_id = re.search(r'/video/(\d+)', video_url).group(1)
    client = await create_client()
    
    try:
        response = await client.get(video_url)
        text = response.text
        
        params = {"aweme_id": video_id, "cursor": 0, "count": max_comments, "current_region": "US", "aid": "1988"}
        
        for pattern in [r'"aid":(\d+)', r'"msToken":"([^"]+)"', r'"region":"([^"]+)"']:
            match = re.search(pattern, text)
            if match and 'aid' in pattern:
                params['aid'] = match.group(1)
            elif match and 'msToken' in pattern:
                params['msToken'] = match.group(1)
            elif match and 'region' in pattern:
                params['region'] = match.group(1)
        
        api_url = "https://www.tiktok.com/api/comment/list/?" + urlencode(params)
        api_response = await client.get(api_url, headers={"accept": "application/json", "referer": video_url})
        
        if api_response.status_code == 200:
            data = api_response.json()
            comments = []
            for comment in data.get('comments', []):
                if comment.get('text'):
                    comments.append({
                        'text': comment.get('text', ''),
                        'author': comment.get('user', {}).get('unique_id', ''),
                        'author_nickname': comment.get('user', {}).get('nickname', ''),
                        'likes': comment.get('digg_count', 0),
                        'replies': comment.get('reply_comment_total', 0)
                    })
            return comments
    except:
        pass
    finally:
        await client.aclose()
    return []

async def main():
    video_url = "https://www.tiktok.com/@kululagu/video/7447897941609630992"
    comments = await scrape_tiktok_comments(video_url)
    
    if not comments:
        print("No comments found")
        return
    
    for i, comment in enumerate(comments, 1):
        author = comment['author']
        nickname = comment['author_nickname']
        text = comment['text']
        likes = comment['likes']
        replies = comment['replies']
        
        display_author = f"@{author}"
        if nickname and nickname != author:
            display_author += f" ({nickname})"
        
        print(f"{i}. {display_author}:")
        print(f"   {text}")
        
        stats = []
        if likes > 0:
            stats.append(f"{likes:,} likes")
        if replies > 0:
            stats.append(f"{replies:,} replies")
        
        if stats:
            print(f"   {', '.join(stats)}")
        
        if i < len(comments):
            print("-" * 50)

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

1. @aadyagurjar (aadya):
   she is me i am her
   7,796 likes, 6 replies
--------------------------------------------------
2. @uqqhi (sophie):
   "I don't feel things for people anymore"
   2,128 likes
--------------------------------------------------
3. @thefoolinthewall (kp𒉭):
   my favorite movies of all time. before sunset is perfect.
   5,582 likes, 2 replies
--------------------------------------------------
4. @lunbottomboot7l (ttennyyapplees):
   "I never felt like it was the right man" she gets it
   5,540 likes, 1 replies
--------------------------------------------------
5. @pris.pls (💘⭐️🧚🏻‍♀️ pris pls 💌🌻🌙):
   shes so real for that tho
   927 likes