Raspagem de Pinterest com Python: "Pins, Boards e Scroll Infinito"

Há alguns meses, um dos nossos engenheiros me mostrou um script em Python que tinha escrito no fim de semana. A ideia era puxar imagens de inspiração de produtos do Pinterest para um projeto de pesquisa de mercado. Ele executou o código e o resultado foi… 16 pins. Em um board com mais de 2.000. Ele ficou encarando a tela, depois me olhou, e soltou: “Acho que o Pinterest está me tirando sarro.”

Ele não está sozinho. Essa é, de longe, a frustração mais comum que vejo entre desenvolvedores tentando fazer scraping do Pinterest com Python. Você abre requests e BeautifulSoup, acessa uma URL do Pinterest e recebe meia dúzia de itens ou um HTML vazio, sem nada útil. O motivo? O Pinterest é uma SPA totalmente renderizada em JavaScript — sua requisição HTTP estática nunca enxerga o conteúdo real. Neste guia, vou mostrar por que isso acontece, quais abordagens realmente funcionam (Playwright, interceptação da API interna e ferramentas no-code como ), e vou trazer exemplos passo a passo para extrair pins, boards, perfis de usuários, scroll infinito e imagens em alta resolução. Seja para montar um scraper pronto para produção ou só pegar dados com rapidez, este artigo vai te ajudar.

O que é raspagem de Pinterest?

Raspagem de Pinterest é o processo de extrair dados do Pinterest de forma programática — como imagens de pins, títulos, descrições, nomes de boards, contagem de seguidores e URLs. Em vez de navegar manualmente e salvar os pins um por um, você usa código (ou uma ferramenta) para coletar dados estruturados de resultados de busca, boards ou perfis de usuários em escala.

Com na plataforma e no fim de 2025, o Pinterest é uma das fontes visuais mais ricas da web. Para empresas, esses dados valem ouro — seja para acompanhar tendências de produtos, comparar conteúdos da concorrência ou montar listas de prospecção com influenciadores.

Por que fazer scraping do Pinterest com Python?

O Pinterest já não é só um mural de inspirações para casamento. Ele virou uma plataforma séria de inteligência de mercado — compraram algo com base em Pins de marcas, e , o que significa que a pessoa entra com intenção, mas sem preferência por uma marca específica. Isso abre uma baita oportunidade de descoberta — e explica por que tantas equipes querem dados estruturados do Pinterest.

Veja como isso se distribui por equipe:

E aqui está o ponto-chave: a API oficial do Pinterest é limitada. Ela exige conta business, aprovação (incluindo uma demonstração em vídeo do seu app) e só libera acesso aos dados da sua própria conta. Se você quer navegar por boards públicos, resultados de busca ou perfis de concorrentes, o scraping é a alternativa prática. Por isso tanta gente recorre ao Python — ou a ferramentas no-code como Thunderbit quando quer resultado sem configuração.

Por que só o BeautifulSoup falha no Pinterest (e o que realmente funciona)

Se você tentou raspar o Pinterest com requests + BeautifulSoup e recebeu 16 itens ou uma página em branco, isso não é imaginação sua. O Pinterest foi construído com React e renderiza 100% do conteúdo via JavaScript. Quando você acessa uma URL do Pinterest com uma requisição HTTP simples, o servidor devolve só um HTML mínimo — alguns <link> e <script> e uma <div> vazia onde o React monta o app. Todos os cards de pins, imagens, títulos e grades aparecem depois que o JavaScript roda no navegador.

Sem execução de JavaScript = sem pins.

Então, o que funciona? Veja como as principais abordagens se comparam:

Para este tutorial, eu recomendo Playwright como abordagem em Python. Ele renderiza JavaScript, suporta simulação de scroll, é bem mantido (, com crescimento de em vagas de emprego) e é em benchmarks. Se você preferir seguir pelo caminho no-code, eu também cubro essa opção.

API oficial do Pinterest vs. raspagem em Python vs. no-code: qual escolher?

Antes de começar a codar, vale perguntar: você realmente precisa fazer isso? Aqui vai um framework de decisão:

Se você é de marketing, operações de e-commerce ou simplesmente quer os dados do Pinterest em uma planilha sem escrever ou manter scripts Python, o é o caminho mais rápido. Você abre qualquer página do Pinterest, clica em “AI Suggest Fields”, toca em “Scrape” e exporta direto para Google Sheets, Excel, Airtable ou Notion. O recurso de scraping de subpáginas ainda pode seguir links individuais de pins para enriquecer os dados automaticamente. Já vi gente da equipe, sem nunca ter escrito uma linha de código, puxar 500+ pins para o Google Sheets em menos de três minutos.

Para quem quer controle total, quer integrar a raspagem a um pipeline em Python ou simplesmente gosta de construir coisas, segue em frente.

Configurando seu ambiente Python para raspar Pinterest

• Dificuldade: Intermediária
• Tempo estimado: ~30–60 minutos (incluindo codificação e testes)
• O que você vai precisar: Python 3.9+, navegador Chrome (para testes), acesso ao terminal/linha de comando

Instale o Playwright e as dependências

Primeiro, crie uma pasta para o projeto e configure um ambiente virtual:

1mkdir pinterest-scraper
2cd pinterest-scraper
3python -m venv venv
4source venv/bin/activate  # No Windows: venv\Scripts\activate

Instale o Playwright e baixe o binário do navegador Chromium:

1pip install playwright
2playwright install chromium

Você também vai usar os módulos nativos do Python json, os e csv para exportar os dados. Não precisa instalar nada extra para isso.

Estrutura da pasta do projeto

Eu recomendo organizar tudo desde o começo:

1pinterest-scraper/
2├── scraper.py
3├── config.py
4├── output/
5│   ├── pins.json
6│   └── pins.csv
7└── images/
8    ├── board-name-1/
9    └── board-name-2/

Em config.py, defina sua string de user agent. O Pinterest bloqueia assinaturas padrão de navegador headless, então use uma realista:

1USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36"

Passo 1: monte a URL de busca do Pinterest

Construa a URL de busca inserindo sua consulta no modelo:

1query = "mid century modern furniture"
2url = f"https://www.pinterest.com/search/pins/?q={query.replace(' ', '%20')}&rs=typed"

Você pode parametrizar isso para qualquer termo de busca. O parâmetro rs=typed informa ao Pinterest que a consulta foi digitada (e não sugerida), o que às vezes afeta a relevância dos resultados.

Passo 2: inicie um navegador headless e carregue a página

Aqui está a configuração central do Playwright. Repare no user agent personalizado — sem isso, o Pinterest provavelmente vai bloquear você ou mostrar uma tela de login.

1import asyncio
2from playwright.async_api import async_playwright
3from config import USER_AGENT
4async def scrape_search(query, max_pins=100):
5    url = f"https://www.pinterest.com/search/pins/?q={query.replace(' ', '%20')}&rs=typed"
6    async with async_playwright() as p:
7        browser = await p.chromium.launch(headless=True)
8        page = await browser.new_page(
9            user_agent=USER_AGENT,
10            viewport={"width": 1920, "height": 1080}
11        )
12        await page.goto(url)
13        await asyncio.sleep(3)  # Aguarda o JS renderizar os pins iniciais

Depois que isso rodar, a página deve ter carregado o primeiro lote de pins — normalmente de 25 a 50.

Passo 3: extraia os dados dos pins da página

O Pinterest envolve cada pin em uma div com data-test-id='pinWrapper'. Dentro dela, você encontra um link (<a>) com a URL do pin e o título (via aria-label) e uma <img> com a URL da miniatura.

1        results = []
2        pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
3        for pin in pins:
4            link = await pin.query_selector("a")
5            if not link:
6                continue
7            title = await link.get_attribute("aria-label") or ""
8            href = await link.get_attribute("href") or ""
9            img = await pin.query_selector("img")
10            src = await img.get_attribute("src") if img else ""
11            results.append({
12                "title": title,
13                "url": f"https://www.pinterest.com{href}" if href.startswith("/") else href,
14                "image_url": src
15            })

Nesse ponto, results contém os pins visíveis na área inicial da tela. Para pegar mais, você precisa rolar a página — e é aí que entra a parte mais importante.

Passo 4: salve os resultados em JSON ou CSV

Depois da extração, grave os dados em arquivos para facilitar o uso:

1import json
2import csv
3def save_json(data, filepath="output/pins.json"):
4    with open(filepath, "w", encoding="utf-8") as f:
5        json.dump(data, f, ensure_ascii=False, indent=2)
6def save_csv(data, filepath="output/pins.csv"):
7    if not data:
8        return
9    with open(filepath, "w", newline="", encoding="utf-8-sig") as f:
10        writer = csv.DictWriter(f, fieldnames=data[0].keys())
11        writer.writeheader()
12        writer.writerows(data)

Use a codificação utf-8-sig no CSV se você for abrir no Excel — isso evita caracteres corrompidos.

Raspar boards inteiros do Pinterest e perfis de usuários

Essa é uma lacuna importante nos tutoriais existentes. Eu não encontrei um único guia concorrente que cubra em profundidade a raspagem de boards ou perfis — e, ainda assim, esse é um dos recursos mais pedidos em fóruns. Os usuários querem baixar todos os pins de um board, organizar imagens em pastas por board e coletar dados de perfil, como contagem de seguidores e lista de boards.

Extraia todos os pins de uma URL de board

As URLs de board seguem este padrão: https://www.pinterest.com/{username}/{board-name}/. A estrutura do DOM é parecida com a dos resultados de busca — os pins ficam em div[data-test-id='pinWrapper'] — mas você precisa rolar a página para carregar tudo.

1async def scrape_board(board_url, max_pins=500):
2    async with async_playwright() as p:
3        browser = await p.chromium.launch(headless=True)
4        page = await browser.new_page(user_agent=USER_AGENT, viewport={"width": 1920, "height": 1080})
5        await page.goto(board_url)
6        await asyncio.sleep(3)
7        seen_ids = set()
8        all_pins = []
9        for scroll_round in range(100):  # Limite de segurança
10            pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
11            new_count = 0
12            for pin in pins:
13                link = await pin.query_selector("a")
14                if not link:
15                    continue
16                href = await link.get_attribute("href") or ""
17                if href in seen_ids:
18                    continue
19                seen_ids.add(href)
20                new_count += 1
21                title = await link.get_attribute("aria-label") or ""
22                img = await link.query_selector("img")
23                src = await img.get_attribute("src") if img else ""
24                all_pins.append({
25                    "title": title,
26                    "url": f"https://www.pinterest.com{href}" if href.startswith("/") else href,
27                    "image_url": src
28                })
29            print(f"Scroll {scroll_round + 1}: {len(all_pins)} pins únicos coletados")
30            if new_count == 0 or len(all_pins) >= max_pins:
31                break
32            prev_height = await page.evaluate("document.body.scrollHeight")
33            await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
34            await asyncio.sleep(2.5)
35            curr_height = await page.evaluate("document.body.scrollHeight")
36            if curr_height == prev_height:
37                break  # Não há mais conteúdo
38        await browser.close()
39        return all_pins

Um ponto de atenção: às vezes as páginas de board têm uma aba “More Ideas” que separa os pins salvos das recomendações algorítmicas. Se você quiser apenas os pins realmente salvos pelo usuário, pare de rolar quando chegar nesse divisor.

Raspe um perfil de usuário: boards, contagem de seguidores e pins

As URLs de perfil têm este formato: https://www.pinterest.com/{username}/. Em uma página de perfil, você pode extrair:

• Contagem de seguidores/seguindo: procure div[data-test-id='follower-count']
• Lista de boards: cada board aparece como um card com link para /{username}/{board-name}/
• Total de pins: às vezes aparece no cabeçalho do perfil

1async def scrape_profile(username):
2    url = f"https://www.pinterest.com/{username}/"
3    async with async_playwright() as p:
4        browser = await p.chromium.launch(headless=True)
5        page = await browser.new_page(user_agent=USER_AGENT, viewport={"width": 1920, "height": 1080})
6        await page.goto(url)
7        await asyncio.sleep(3)
8        # Extrai a contagem de seguidores
9        follower_el = await page.query_selector("div[data-test-id='follower-count']")
10        followers = await follower_el.inner_text() if follower_el else "N/A"
11        # Extrai os links dos boards
12        board_links = await page.query_selector_all("a[href*='/" + username + "/']")
13        boards = []
14        for bl in board_links:
15            href = await bl.get_attribute("href") or ""
16            name = await bl.get_attribute("aria-label") or href.split("/")[-2]
17            if href.count("/") >= 3 and href != f"/{username}/":
18                boards.append({"name": name, "url": f"https://www.pinterest.com{href}"})
19        await browser.close()
20        return {"username": username, "followers": followers, "boards": boards}

Para raspar todos os pins de cada board de um perfil, percorra a lista de boards e chame scrape_board() para cada um. Você pode organizar as imagens baixadas automaticamente em pastas separadas por board.

Criando um handler de scroll infinito pronto para produção

Essa é a parte que separa um scraper amador de um de verdade. O principal problema — e eu já vi isso em mais de uma dúzia de tópicos em fóruns — é que os scrapers retornam só 16–25 itens porque não rolam a página o suficiente, ou usam uma contagem fixa como for i in range(5): scroll() e torcem para dar certo.

Essa abordagem não é confiável. O Pinterest carrega novos conteúdos em blocos de cerca de 25 pins, acionados por eventos de scroll. Se você rolar cinco vezes, pode conseguir 125 pins — ou 75, se a rede estiver lenta, ou 150, se os lotes forem menores. Você precisa de um padrão mais inteligente.

O padrão “rolar até não aparecer mais conteúdo novo”

Aqui vai uma função robusta de scroll que acompanha IDs únicos dos pins, usa timeout configurável, inclui lógica de tentativa e imprime progresso:

1import time
2import random
3async def scroll_and_collect(page, max_pins=1000, max_scrolls=200, scroll_pause=2.5):
4    seen_ids = set()
5    all_pins = []
6    no_new_count = 0
7    for i in range(max_scrolls):
8        pins = await page.query_selector_all("div[data-test-id='pinWrapper']")
9        new_this_round = 0
10        for pin in pins:
11            link = await pin.query_selector("a")
12            if not link:
13                continue
14            href = await link.get_attribute("href") or ""
15            if href in seen_ids:
16                continue
17            seen_ids.add(href)
18            new_this_round += 1
19            title = await link.get_attribute("aria-label") or ""
20            img = await link.query_selector("img")
21            src = await img.get_attribute("src") if img else ""
22            all_pins.append({
23                "title": title,
24                "url": f"https://www.pinterest.com{href}" if href.startswith("/") else href,
25                "image_url": src
26            })
27        print(f"  Scroll {i+1}: {new_this_round} novos pins | {len(all_pins)} pins únicos no total")
28        if len(all_pins) >= max_pins:
29            print(f"  Limite de max_pins atingido ({max_pins}). Parando.")
30            break
31        if new_this_round == 0:
32            no_new_count += 1
33            if no_new_count >= 3:
34                print("  Sem novos pins após 3 scrolls consecutivos. Fim do conteúdo.")
35                break
36        else:
37            no_new_count = 0
38        prev_height = await page.evaluate("document.body.scrollHeight")
39        await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
40        await asyncio.sleep(scroll_pause + random.uniform(0.5, 1.5))
41        curr_height = await page.evaluate("document.body.scrollHeight")
42        if curr_height == prev_height and new_this_round == 0:
43            print("  Altura da página inalterada e sem novos pins. Provável fim do feed.")
44            break
45    return all_pins

Por que essa estrutura funciona:

• Deduplicação por href: a URL de cada pin é única, então usamos isso como ID. Isso evita contar o mesmo pin duas vezes quando o DOM é re-renderizado durante o scroll.
• Regra dos três avisos: se três scrolls seguidos retornarem zero novos pins, paramos. Isso cobre o caso em que a página ainda está carregando, mas não existe mais conteúdo novo.
• Variação aleatória no intervalo: adicionar 0,5 a 1,5 segundo de atraso aleatório entre os scrolls deixa o comportamento mais humano e reduz a chance de acionar mecanismos anti-bot.
• Limite de segurança de max_scrolls: evita loop infinito se algo der errado.

Lidando com casos extremos

• Quebra no “More Ideas”: nas páginas de board, o Pinterest às vezes insere uma seção “More Ideas”. Se você quiser apenas os pins reais do board, pode verificar esse elemento e parar de rolar quando ele aparecer.
• Rate limiting em sessões longas: se você estiver percorrendo um board com milhares de pins, o Pinterest pode começar a limitar as respostas. Se notar scrolls com zero novos pins de forma intermitente (e não três seguidos), aumente o intervalo de scroll para 5+ segundos.

Como obter imagens do Pinterest em resolução total, não miniaturas

Essa parte irrita muita gente. Você raspa vários pins, baixa as imagens e elas aparecem como miniaturas minúsculas de 236px. Em fóruns, o pessoal descreve isso como “qualidade lixo, pequena demais”. A solução é entender a estrutura da URL das imagens do Pinterest.

Entendendo os caminhos das URLs de imagem do Pinterest

Todas as imagens do Pinterest são servidas em https://i.pinimg.com/{size}/{hash}.jpg. O segmento {size} controla a resolução:

Função utilitária: atualizar qualquer URL de imagem do Pinterest para a máxima resolução

Aqui está uma função que reescreve qualquer URL de imagem do Pinterest para a maior qualidade disponível, com lógica de fallback:

1import requests as req
2def upgrade_image_url(url, preferred_size="originals"):
3    """Reescreve uma URL de imagem do Pinterest para a maior resolução disponível."""
4    sizes = ["originals", "736x", "474x", "236x"]
5    if preferred_size not in sizes:
6        preferred_size = "originals"
7    for size in sizes[sizes.index(preferred_size):]:
8        upgraded = url
9        for s in sizes:
10            upgraded = upgraded.replace(f"/{s}/", f"/{size}/")
11        try:
12            resp = req.head(upgraded, timeout=5, allow_redirects=True)
13            if resp.status_code == 200:
14                return upgraded
15        except Exception:
16            continue
17    return url  # Retorna a original se tudo falhar

Observação importante (até 2025): o caminho /originals/ vem retornando cada vez mais erros HTTP 403 Forbidden. Um confirma esse comportamento em meados de 2025. O máximo confiável costuma ser /736x/. Minha função tenta primeiro /originals/ e depois faz fallback automático para /736x/.

Baixando imagens para pastas organizadas

1import os
2import time
3def download_images(pins, folder="images/default", delay=1.5):
4    os.makedirs(folder, exist_ok=True)
5    for i, pin in enumerate(pins):
6        img_url = upgrade_image_url(pin.get("image_url", ""), preferred_size="736x")
7        if not img_url:
8            continue
9        filename = f"pin_{i+1}.jpg"
10        filepath = os.path.join(folder, filename)
11        try:
12            resp = req.get(img_url, timeout=15)
13            if resp.status_code == 200:
14                with open(filepath, "wb") as f:
15                    f.write(resp.content)
16                print(f"  Baixado {filename} ({len(resp.content) // 1024} KB)")
17            else:
18                print(f"  Falha em {filename}: HTTP {resp.status_code}")
19        except Exception as e:
20            print(f"  Erro ao baixar {filename}: {e}")
21        time.sleep(delay + random.uniform(0.3, 0.8))

Adicione um atraso entre os downloads para limitar a taxa. Eu uso de 1,5 a 2,3 segundos com variação aleatória. Sem isso, o Pinterest pode bloquear seu IP depois de algumas centenas de requisições.

Exportando seus dados raspados do Pinterest

Exportar para CSV ou JSON

Já cobrimos o básico antes. Para conjuntos maiores de dados (10.000+ pins), considere o formato JSON Lines — um objeto JSON por linha — que é mais fácil de transmitir e processar:

1def save_jsonl(data, filepath="output/pins.jsonl"):
2    with open(filepath, "w", encoding="utf-8") as f:
3        for item in data:
4            f.write(json.dumps(item, ensure_ascii=False) + "\n")

Exportar para Google Sheets, Airtable ou Notion

Se você quiser enviar os dados diretamente do Python para o Google Sheets, vai precisar da biblioteca gspread e de uma service account do Google Cloud. Para Airtable, use pyairtable. Para Notion, notion-client. Cada uma dessas opções exige configuração de chave de API e adiciona complexidade real ao pipeline.

Ou — e aqui talvez eu tenha uma opinião tendenciosa, mas é verdadeiramente o caminho mais rápido — você pode usar o para raspar o Pinterest e exportar para qualquer um desses destinos com um clique. Sem chaves de API, sem service accounts, sem código extra. A faz a exportação de forma nativa.

Dicas para evitar bloqueios ao raspar Pinterest

O sistema anti-bot do Pinterest recebe nota pela ScrapeOps — não é trivial, mas também não é o mais difícil de driblar. Ele usa fingerprinting de navegador, análise comportamental e limitação por IP. O que funciona:

• Gire user agents: use um conjunto de user agents reais do Chrome e escolha um aleatoriamente por sessão.
• Adicione atrasos aleatórios: 2–5 segundos entre scrolls e requisições, com variação. Em sessões sem proxy, aumente para 10–15 segundos.
• Use uma viewport realista: defina viewport={"width": 1920, "height": 1080} — não use dimensões pequenas ou estranhas.
• Considere proxies em escala: se você for raspar milhares de pins, alterne proxies residenciais. Sem isso, espere bloqueios de IP depois de algumas centenas de requisições.
• Respeite o robots.txt: o robots.txt do Pinterest bloqueia a maioria dos crawlers automatizados e tem . Leve isso em conta para conformidade.
• Evite raspagem com login: fique no conteúdo público enquanto estiver deslogado. Raspar atrás de autenticação aumenta os riscos legais e técnicos.

O Thunderbit lida automaticamente com anti-bot e CAPTCHA por meio do seu motor de IA — mais uma preocupação a menos se você optar pelo no-code.

Considerações legais e éticas para raspagem do Pinterest

Vou ser breve aqui porque esse não é o foco do artigo, mas isso importa.

Os Termos de Serviço do Pinterest (Seção 2a) dizem que você concorda em não “raspar, coletar, pesquisar, copiar ou de outra forma acessar dados ou conteúdo do Pinterest de maneiras não autorizadas, como por meios automatizados (sem nossa permissão prévia e expressa).” Dito isso, os tribunais geralmente entendem que a raspagem de dados publicamente disponíveis não viola o Computer Fraud and Abuse Act — veja e Meta v. Bright Data (jan. de 2024), onde o tribunal decidiu que raspar dados visíveis publicamente enquanto deslogado é legal.

Algumas regras básicas:

• Raspe apenas conteúdo visível publicamente e sem login
• Não use os dados raspados para spam nem para se passar por usuários
• Respeite os direitos autorais das imagens — extraia metadados sempre que possível e evite redistribuir comercialmente imagens protegidas sem permissão
• Se você pretende usar os dados raspados para fins comerciais, consulte um advogado

Para uma análise mais profunda do cenário legal, veja nosso .

Conclusão: o que você aprendeu e para onde ir agora

Agora você já sabe por que a raspagem estática falha no Pinterest (é uma SPA em React — sem JavaScript, sem dados), como usar o Playwright para raspar resultados de busca, boards e perfis de usuários, como montar um handler de scroll infinito pronto para produção que não para depois de 16 pins e como obter imagens em alta resolução em vez de miniaturas minúsculas.

Resumo rápido do que importa:

• requests + BeautifulSoup não funciona no Pinterest. Não perca seu tempo.
• Playwright é a melhor ferramenta em Python para essa tarefa — rápida, bem suportada e capaz de renderizar JS nativamente.
• Scroll infinito precisa de um loop baseado em deduplicação, não de uma contagem fixa.
• Imagens em alta resolução exigem reescrita do caminho da URL — mire em /736x/ (já que /originals/ muitas vezes retorna 403).
• Raspagem de boards e perfis é pouco explorada em tutoriais existentes, mas é simples com os seletores certos.
• Para quem não programa ou quer velocidade, o permite raspar Pinterest em 2 cliques e exportar para Google Sheets, Excel, Airtable ou Notion — sem precisar de Python. Teste grátis pela .

Se você estiver montando um pipeline em Python, o código deste guia já te dá uma base sólida. Se você só precisa dos dados, o Thunderbit é o atalho. De qualquer forma, você já não está mais preso a 16 pins e a uma cara de decepção.

Para saber mais sobre scraping e extração de dados, confira nossos guias sobre , e . Você também pode explorar os ou assistir aos tutoriais no .

FAQs

1. Dá para raspar o Pinterest com BeautifulSoup?

Não de forma eficaz sozinho. O Pinterest renderiza todo o conteúdo via JavaScript, então requests + BeautifulSoup só enxerga um HTML vazio. Você precisa de um navegador headless como Playwright ou Selenium para renderizar a página antes, ou pode usar uma ferramenta no-code como o Thunderbit, que lida com a renderização de JS automaticamente.

2. Quantos pins dá para raspar do Pinterest em uma sessão?

Depende da sua lógica de scroll e de como você lida com anti-bot. Com o handler de scroll infinito pronto para produção deste guia (deduplicação, timeout, lógica de retry), você consegue raspar com confiabilidade centenas ou milhares de pins por board ou consulta de busca. Em boards muito grandes, espere gastar alguns minutos rolando e coletando.

3. Por que as imagens raspadas do Pinterest ficam tão pequenas?

Por padrão, o Pinterest entrega miniaturas /236x/ na visualização em grade. Para obter resolução mais alta, reescreva o caminho da URL da imagem para /736x/ ou /originals/. Observe que /originals/ vem retornando erros 403 com mais frequência em 2025, então /736x/ é o máximo confiável.

4. É legal raspar o Pinterest?

A raspagem de dados publicamente disponíveis é, em geral, aceita por decisões judiciais recentes (por exemplo, hiQ v. LinkedIn, Meta v. Bright Data), mas os Termos de Serviço do Pinterest proíbem acesso automatizado não autorizado. Fique com conteúdo público, não use os dados para spam, respeite direitos autorais e consulte um advogado para usos comerciais.

5. Qual é a melhor alternativa no-code para raspar Pinterest?

O extrai dados de pins do Pinterest — títulos, imagens, URLs, descrições — em 2 cliques, com exportação integrada para Google Sheets, Excel, Airtable ou Notion. Ele lida automaticamente com renderização JavaScript, scroll infinito e desafios anti-bot, então você não precisa escrever nem manter código.

Saiba mais