Automatize sua pesquisa de mercado: extraia dados do Shopify com Python

O endpoint /products.json do Shopify é um dos segredos mais conhecidos — e menos falados — do mundo dos dados em ecommerce. É só acrescentá-lo à URL de qualquer loja Shopify para receber JSON estruturado de volta, sem chaves de API, sem autenticação e sem precisar fuçar HTML aninhado.

Faço parte da equipe do , então passo bastante tempo pensando em como as pessoas extraem dados da web. E o scraping de Shopify aparece o tempo todo: times de vendas acompanhando preços da concorrência, operações de ecommerce comparando catálogos, profissionais de compras buscando novos fornecedores. Com no Shopify e a plataforma concentrando cerca de , o volume de dados de produtos disponíveis para coleta é enorme.

Este guia cobre o processo completo: o que o endpoint retorna, como paginar milhares de produtos, como lidar com limites de requisições sem ser bloqueado e como transformar o JSON aninhado do Shopify em um CSV ou arquivo Excel limpo usando pandas. Também vou apresentar endpoints que quase ninguém menciona (/collections.json, /meta.json) e mostrar uma alternativa sem código para quem prefere evitar Python.

O que é o endpoint /products.json do Shopify e por que ele facilita tanto o scraping?

Toda loja Shopify tem um endpoint público em {store-url}/products.json que retorna dados estruturados dos produtos. Sem chave de API. Sem OAuth. Sem autenticação de nenhum tipo. Você literalmente adiciona /products.json à URL da loja e recebe uma lista JSON com todos os produtos do catálogo.

Teste agora mesmo: abra ou no navegador. Você vai ver um JSON limpo e estruturado com títulos, preços, variantes, imagens, tags — tudo isso.

Compare isso com a alternativa: analisar os temas HTML do Shopify, que são profundamente aninhados, inconsistentes entre lojas e mudam sempre que o lojista atualiza o tema. Veja com o que você teria de lidar:

Abordagem com HTML (dolorosa):

1<div class="product-card__info">
2  <h3 class="product-card__title">
3    <a href="/products/classic-blue-jeans">Classic Blue Jeans</a>
4  </h3>
5  <span class="price price--on-sale" data-product-price>$149.00</span>
6</div>

Abordagem com JSON (limpa):

1{
2  "title": "Classic Blue Jeans",
3  "handle": "classic-blue-jeans",
4  "vendor": "Hiut Denim",
5  "variants": [{"price": "149.00", "sku": "HD-BLU-32", "available": true}]
6}

JSON ganha em consistência, confiabilidade e facilidade de leitura. O endpoint também aceita dois parâmetros importantes de consulta — ?limit= (até 250 produtos por página, com padrão de 30) e ?page= para paginação — que vamos usar bastante no código abaixo.

Um ponto importante: este é um endpoint público da loja, não a . A Admin API exige tokens de acesso do dono da loja e fornece dados de pedidos, níveis de estoque e informações de clientes. O endpoint público /products.json é somente leitura e qualquer pessoa pode acessar. Mais adiante, explico essa diferença em detalhes, porque há muita confusão sobre isso em fóruns.

Um aviso: nem toda loja Shopify expõe esse endpoint. Nos meus testes, cerca de 71% das lojas retornam JSON válido (allbirds.com, gymshark.com, colourpop.com e kyliecosmetics.com funcionam), enquanto algumas configurações personalizadas retornam 404 (hiutdenim.co.uk, bombas.com). A verificação rápida é simples: acesse {store-url}/products.json no navegador e veja o resultado.

Por que extrair dados do Shopify com Python? Principais usos no negócio

Por que se preocupar com isso? ROI. já usam coleta automatizada de preços para inteligência competitiva, contra apenas 34% em 2020. E pesquisas mostram que uma . Esses dados valem dinheiro de verdade.

Aqui estão os casos de uso mais comuns que eu vejo:

This paragraph contains content that cannot be parsed and has been skipped.

Python é a escolha natural para esse trabalho. usam Python como linguagem principal, e o ecossistema — requests para HTTP, pandas para manipulação de dados, httpx para chamadas assíncronas — facilita sair de “tenho uma URL” para “tenho uma planilha” em menos de 80 linhas de código.

Referência completa dos campos de products.json: explicação de cada campo

A maioria dos tutoriais mostra title, id e handle e segue em frente. Mas a resposta JSON do Shopify contém mais de 40 campos em produtos, variantes, imagens e opções. Saber o que existe antes de escrever o scraper evita retrabalho depois.

Compilei esta referência a partir de respostas reais de /products.json coletadas em 16 de abril de 2026. A estrutura é consistente em todas as lojas que expõem o endpoint.

Campos no nível do produto

Campos no nível da variante (aninhados em cada produto)

Campos no nível da imagem

O que NÃO está no endpoint público

Um ponto crítico: inventory_quantity NÃO está disponível nas respostas públicas de /products.json. Esse campo foi removido dos endpoints públicos em dezembro de 2017 por motivos de segurança. O único indicador de estoque que você recebe é o campo booleano available em cada variante (true ou false). Para acessar quantidades reais de inventário, é preciso usar a Admin API autenticada com credenciais do proprietário da loja.

Antes de escrever seu scraper, leia esta tabela e defina quais campos são importantes para o seu caso. Se o foco for monitoramento de preços, você precisa de variants[].price, variants[].compare_at_price e variants[].available. Se o objetivo for geração de leads, concentre-se em vendor, product_type e tags. Filtre de acordo — seu CSV vai ficar muito mais limpo.

Além de products.json: collections, meta e outros endpoints do Shopify

Nenhum tutorial concorrente menciona estes endpoints. Eles são essenciais para trabalhos sérios de inteligência competitiva.

/collections.json — Todas as categorias da loja

Retorna todas as coleções (categorias) da loja com títulos, handles, descrições e contagem de produtos. Verifiquei isso em zoologistperfumes.com, allbirds.com e gymshark.com — todos retornaram JSON válido.

1{
2  "collections": [
3    {
4      "id": 308387348539,
5      "title": "Attars",
6      "handle": "attars",
7      "published_at": "2026-03-29T12:20:32-04:00",
8      "products_count": 1,
9      "image": { "src": "https://cdn.shopify.com/..." }
10    }
11  ]
12}

Quer entender como um concorrente organiza o catálogo? Este é o endpoint.

/collections/{handle}/products.json — Produtos por categoria

Retorna produtos filtrados por uma coleção específica. A estrutura JSON é a mesma de /products.json, mas limitada a uma categoria. Isso é essencial para scraping por categoria — por exemplo, se você só quiser acompanhar a coleção “Sale” ou “New Arrivals” de um concorrente.

/meta.json — Metadados da loja

Retorna nome da loja, descrição, moeda, país e — aqui está o ponto forte — published_products_count. Esse número permite calcular com antecedência quantas páginas de paginação serão necessárias: ceil(published_products_count / 250). Nada de ficar incrementando página às cegas até receber uma resposta vazia.

Qual endpoint você deve usar?

A pergunta que sempre aparece em fóruns — “Posso descobrir quantas unidades um concorrente vendeu?” — tem uma resposta curta: não. Não por endpoints públicos. Dados de vendas e quantidades de estoque exigem a Admin API autenticada, o que significa que você precisa ter acesso do dono da loja. Os endpoints públicos fornecem só dados do catálogo.

Como extrair dados do Shopify com Python: configuração passo a passo

• Dificuldade: Iniciante
• Tempo necessário: ~15 minutos (configuração + primeira extração)
• O que você vai precisar: Python 3.11+, pip, um terminal e a URL de uma loja Shopify para extrair

Passo 1: Instale o Python e as bibliotecas necessárias

Verifique se você tem Python 3.11 ou mais recente instalado (o pandas 3.0.x exige isso). Depois, instale as duas bibliotecas que vamos usar:

1pip install requests pandas

Para exportar para Excel, você também vai precisar de:

1pip install openpyxl

No topo do seu script, adicione estes imports:

1import requests
2import pandas as pd
3import time
4import random
5import json

Você não deve ver erros de importação ao rodar o script. Se o pandas acusar erro de versão, atualize o Python para 3.12.

Passo 2: Busque os dados de produtos em /products.json

Aqui está uma função básica que recebe a URL da loja, acessa o endpoint e retorna o JSON parseado:

1def fetch_products_page(store_url, page=1, limit=250):
2    """Busca uma página de produtos de uma loja Shopify."""
3    url = f"{store_url.rstrip('/')}/products.json"
4    params = {"limit": limit, "page": page}
5    headers = {
6        "User-Agent": "Mozilla/5.0 (compatible; ProductResearch/1.0)"
7    }
8    response = requests.get(url, params=params, headers=headers, timeout=30)
9    response.raise_for_status()
10    return response.json().get("products", [])

Detalhes importantes:

• limit=250 é o máximo permitido pelo Shopify por página. O padrão é 30, então definir isso explicitamente reduz suas requisições totais em até 8x.
• Cabeçalho User-Agent: sempre use um valor realista. Requisições sem User-Agent têm mais chance de acionar os sistemas anti-bot do Shopify.
• timeout=30: não deixe uma requisição travar para sempre.

Teste com uma loja conhecida:

1products = fetch_products_page("https://allbirds.com")
2print(f"Fetched {len(products)} products")
3print(f"First product: {products[0]['title']}")

Você deve ver algo como: Fetched 250 products e o título do primeiro produto.

Passo 3: Trate a paginação para extrair todos os produtos

Uma única requisição retorna no máximo 250 produtos. A maioria das lojas tem mais do que isso (a Allbirds tem 1.420+). Você precisa iterar pelas páginas até receber uma resposta vazia.

1def scrape_all_products(store_url, delay=1.0):
2    """Extrai todos os produtos de uma loja Shopify, tratando paginação."""
3    all_products = []
4    page = 1
5    while True:
6        print(f"Fetching page {page}...")
7        products = fetch_products_page(store_url, page=page, limit=250)
8        if not products:
9            print(f"No more products. Total: {len(all_products)}")
10            break
11        all_products.extend(products)
12        print(f"  Got {len(products)} products (total so far: {len(all_products)})")
13        page += 1
14        # Seja educado: aguarde entre as requisições
15        time.sleep(delay + random.uniform(0, 0.5))
16    return all_products

Quando products vier vazio, você chegou ao fim.

O time.sleep() com um pequeno jitter aleatório ajuda a ficar abaixo do limite informal do Shopify (~2 requisições/segundo).

Dica de ouro: se você consultar /meta.json antes, já vai saber a contagem total de produtos e poderá calcular exatamente quantas páginas precisa: pages = ceil(product_count / 250). Isso evita a “requisição vazia extra” no fim.

Passo 4: Parseie e selecione os campos de que você precisa

Agora que você tem todos os produtos como uma lista Python de dicionários, extraia só os campos que importam. Aqui vai um exemplo com os campos mais usados para monitoramento de preços:

1def extract_product_data(products):
2    """Extrai campos principais dos produtos, achatando as variantes."""
3    rows = []
4    for product in products:
5        for variant in product.get("variants", []):
6            rows.append({
7                "product_id": product["id"],
8                "title": product["title"],
9                "handle": product["handle"],
10                "vendor": product.get("vendor", ""),
11                "product_type": product.get("product_type", ""),
12                "tags": ", ".join(product.get("tags", [])),
13                "created_at": product.get("created_at", ""),
14                "variant_id": variant["id"],
15                "variant_title": variant.get("title", ""),
16                "sku": variant.get("sku", ""),
17                "price": variant.get("price", ""),
18                "compare_at_price": variant.get("compare_at_price", ""),
19                "available": variant.get("available", ""),
20                "image_url": product["images"][0]["src"] if product.get("images") else ""
21            })
22    return rows

Isso cria uma linha por variante — o formato mais útil para comparação de preços, já que um produto como “Classic Blue Jeans” pode ter 12 variantes (6 tamanhos × 2 cores), cada uma com preço e disponibilidade próprios.

Exportar dados coletados do Shopify para CSV e Excel com pandas

A maioria dos outros tutoriais de scraping do Shopify despeja o JSON bruto em um arquivo e encerra por aí. Ótimo para desenvolvedores. Pouco útil para o analista de ecommerce que precisa de uma planilha até sexta-feira.

O problema: o JSON do Shopify é aninhado. Um produto pode conter uma dúzia de variantes, cada uma com seu preço, SKU e disponibilidade. Transformar isso em linhas e colunas exige algum trabalho com pandas.

Achate o JSON aninhado em uma tabela limpa

Há duas abordagens, dependendo do seu caso de uso:

Opção A: uma linha por variante (melhor para monitoramento de preços e estoque)

1# Usando a função extract_product_data do Passo 4
2products = scrape_all_products("https://allbirds.com")
3rows = extract_product_data(products)
4df = pd.DataFrame(rows)
5print(f"DataFrame shape: {df.shape}")
6print(df.head())

Isso gera uma tabela plana em que cada linha é uma combinação única de produto + variante. Uma loja com 500 produtos e média de 4 variantes por produto resulta em um DataFrame com cerca de 2.000 linhas.

Opção B: uma linha por resumo de produto (melhor para visão geral do catálogo)

1def summarize_products(products):
2    """Uma linha por produto com preço mínimo/máximo entre variantes."""
3    rows = []
4    for product in products:
5        prices = [float(v["price"]) for v in product.get("variants", []) if v.get("price")]
6        rows.append({
7            "product_id": product["id"],
8            "title": product["title"],
9            "vendor": product.get("vendor", ""),
10            "product_type": product.get("product_type", ""),
11            "variant_count": len(product.get("variants", [])),
12            "min_price": min(prices) if prices else None,
13            "max_price": max(prices) if prices else None,
14            "any_available": any(v.get("available", False) for v in product.get("variants", [])),
15            "tags": ", ".join(product.get("tags", []))
16        })
17    return rows

Exporte para CSV, Excel e Google Sheets

1# Exportação para CSV (use utf-8-sig para o Excel lidar bem com caracteres especiais)
2df.to_csv("shopify_products.csv", index=False, encoding="utf-8-sig")
3# Exportação para Excel (requer openpyxl)
4df.to_excel("shopify_products.xlsx", index=False, engine="openpyxl")
5print("Exported to shopify_products.csv and shopify_products.xlsx")

Para Google Sheets, você pode usar a biblioteca gspread com uma conta de serviço, mas, sinceramente, para a maioria dos casos, exportar para CSV e mandar para o Google Drive é mais rápido e simples.

Scraping em produção com Python: limites, retries e anti-bloqueio

O script básico funciona bem para lojas pequenas. Mas e para uma loja com mais de 5.000 produtos, ou para acessar várias lojas em sequência? É aí que começam os problemas.

Entendendo os limites e bloqueios do Shopify

Os endpoints públicos em JSON do Shopify não têm limites de requisição formalmente documentados (ao contrário do modelo de “leaky bucket” da Admin API), mas os testes práticos mostram:

• Taxa segura: cerca de 2 requisições por segundo por loja
• Teto suave: cerca de 40 requisições por minuto antes de o throttling começar
• HTTP 429: “Too Many Requests” — resposta padrão de limite excedido
• HTTP 430: código específico do Shopify indicando bloqueio de segurança, não apenas limitação de taxa
• HTTP 403 ou redirecionamento para CAPTCHA: algumas lojas com proteção extra da Cloudflare

Requisições vindas de infraestrutura em nuvem compartilhada (AWS Lambda, Google Cloud Run) têm chance maior de bloquear, porque esses ranges de IP costumam registrar mais abuso.

Técnicas para extrair dados do Shopify com confiabilidade

Veja a evolução de “funciona no meu notebook” para “roda em produção”:

Nível intermediário (recomendado para a maioria dos usuários):

1import requests
2from requests.adapters import HTTPAdapter
3from urllib3.util.retry import Retry
4> This paragraph contains content that cannot be parsed and has been skipped.
5A configuração de `Retry` trata respostas 429 automaticamente com backoff exponencial. O `backoff_factor=1` significa que a sequência de espera é 0,5s → 1s → 2s → 4s → 8s entre as tentativas. Reutilizar a sessão (`requests.Session()`) também oferece pooling de conexão, reduzindo a sobrecarga quando você faz várias requisições para o mesmo domínio.
6**Rotação de User-Agent**: se você estiver extraindo várias lojas, alterne entre 3 a 5 strings realistas de User-Agent de navegador. Não é para “enganar” ninguém — é só para não parecer um bot que manda sempre os mesmos cabeçalhos.
7<iframe width="560" height="315" src="https://www.youtube.com/embed/p3Z-qtUp4p8" title="Web Scraping Project: Save Shopify Products to Database" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>
8## Script Python completo para extrair Shopify com exportação para CSV
9Aqui está o script completo, pronto para copiar e colar, que junta tudo o que mostramos acima. Ele tem cerca de 75 linhas de código de fato (mais comentários) e foi testado com Allbirds (1.420 produtos), ColourPop (2.000+ produtos) e Zoologist Perfumes (catálogo pequeno).
10```python
11import requests
12import pandas as pd
13import time
14import random
15from requests.adapters import HTTPAdapter
16from urllib3.util.retry import Retry
17> This paragraph contains content that cannot be parsed and has been skipped.
18def scrape_shopify(store_url, delay=1.0):
19    """Extrai todos os produtos de uma loja Shopify via /products.json."""
20    session = create_session()
21    all_products = []
22    page = 1
23    base_url = f"{store_url.rstrip('/')}/products.json"
24> This paragraph contains content that cannot be parsed and has been skipped.
25        if not products:
26            break
27        all_products.extend(products)
28        print(f"{len(products)} products (total: {len(all_products)})")
29        page += 1
30        time.sleep(delay + random.uniform(0, 0.5))
31    return all_products
32> This paragraph contains content that cannot be parsed and has been skipped.
33if __name__ == "__main__":
34    STORE_URL = "https://allbirds.com"  # Troque pela loja alvo
35    OUTPUT_CSV = "shopify_products.csv"
36    OUTPUT_EXCEL = "shopify_products.xlsx"
37    print(f"Scraping {STORE_URL}...")
38    products = scrape_shopify(STORE_URL)
39    print(f"\nTotal products scraped: {len(products)}")
40    print("Flattening to variant-level rows...")
41    rows = flatten_to_variants(products)
42    df = pd.DataFrame(rows)
43    print(f"DataFrame: {df.shape[0]} rows x {df.shape[1]} columns")
44    df.to_csv(OUTPUT_CSV, index=False, encoding="utf-8-sig")
45    df.to_excel(OUTPUT_EXCEL, index=False, engine="openpyxl")
46    print(f"\nExported to {OUTPUT_CSV} and {OUTPUT_EXCEL}")

Execute com python scrape_shopify.py. Para Allbirds, isso leva cerca de 45 segundos e gera um CSV com ~5.000+ linhas (uma por variante). A saída no terminal fica algo assim:

1Scraping https://allbirds.com...
2  Page 1... 250 products (total: 250)
3  Page 2... 250 products (total: 500)
4  ...
5  Page 6... 170 products (total: 1420)
6Total products scraped: 1420
7Flattening to variant-level rows...
8DataFrame: 5680 rows x 14 columns
9Exported to shopify_products.csv and shopify_products.xlsx

Sem Python: extraia Shopify em 2 cliques com Thunderbit (alternativa no-code)

Nem todo mundo quer instalar Python, resolver erros de importação ou manter um script de scraping. Para o vendedor que precisa de preços da concorrência já para amanhã de manhã, Python é exagero.

Foi por isso que criamos o — um AI web scraper que funciona como extensão do Chrome. Sem código, sem chave de API, sem configurar ambiente.

Como o Thunderbit extrai dados de lojas Shopify

O Thunderbit tem um template de Shopify Scraper dedicado e pré-configurado para páginas de produtos do Shopify. Você instala a , acessa uma loja Shopify e clica em “Scrape”. O template extrai automaticamente nomes de produtos, descrições, preços, detalhes de variantes, imagens e informações de fornecedor.

Em lojas em que o template não encaixa perfeitamente (temas personalizados, layouts incomuns), o recurso AI Suggest Fields do Thunderbit lê a página e gera nomes de colunas automaticamente. Você pode personalizar isso — renomear colunas, adicionar campos e escrever instruções como “extrair apenas produtos com compare_at_price definido”.

Alguns recursos que correspondem diretamente ao que o script em Python faz:

• Scraping de subpáginas: visita automaticamente cada página de produto e enriquece a tabela com descrições completas, avaliações ou detalhes de variantes — o mesmo que nosso script Python faz ao iterar pelas páginas, mas sem código.
• Paginação automática: lida com paginação por clique e rolagem infinita sem configuração.
• Scraping agendado: configure tarefas recorrentes (por exemplo, “toda segunda-feira às 9h”) para monitoramento contínuo de preços — sem cron job ou servidor.
• Exportação gratuita para CSV, Excel, Google Sheets, Airtable ou Notion em todos os planos.

Script em Python vs. Thunderbit: comparação honesta

Use Python quando você precisar de controle total ou estiver integrando tudo em um pipeline maior de dados. Use o Thunderbit quando precisar dos dados rápido e não quiser manter código. Para uma análise mais profunda sobre , publicamos um guia separado sobre o tema.

Dicas e boas práticas para extrair dados de lojas Shopify

Estas recomendações valem independentemente da ferramenta que você escolher:

• Sempre use ?limit=250 para reduzir o número total de requisições. O padrão de 30 por página gera 8x mais chamadas para os mesmos dados.
• Respeite a loja: adote pausas de 1 a 2 segundos entre requisições. Sobrecarregar um servidor com chamadas em sequência é má prática e aumenta a chance de bloqueio.
• Verifique o robots.txt primeiro: o robots.txt padrão do Shopify NÃO bloqueia /products.json. Mas algumas lojas adicionam regras personalizadas, então confirme antes de extrair em escala.
• Salve o JSON bruto localmente primeiro e só depois processe. Se sua lógica de parsing mudar depois, você não precisará fazer o scraping de novo. Um simples json.dump(all_products, open("raw_data.json", "w")) antes de achatar os dados já evita muita dor de cabeça.
• Remova duplicatas por product.id: em bordas de paginação, às vezes o mesmo produto aparece mais de uma vez. Um df.drop_duplicates(subset=["product_id", "variant_id"]) resolve isso rápido.
• Converta price para float antes de fazer cálculos. O Shopify retorna preços como string ("185.00"), não como número.
• Fique atento a mudanças no endpoint: embora /products.json esteja estável há anos, o Shopify teoricamente poderia restringi-lo. Se o scraper começar a retornar 404 de repente, verifique a loja manualmente primeiro.

Para saber mais sobre como construir scrapers robustos, confira nosso guia sobre .

Considerações legais e éticas ao extrair dados do Shopify

É uma seção curta, mas importante.

O endpoint /products.json entrega dados de produtos publicamente disponíveis — as mesmas informações que qualquer visitante vê ao navegar pela loja. Os Termos de Serviço do Shopify incluem linguagem sobre não usar “meios automatizados” para acessar “os Serviços”, mas essa redação se refere à própria plataforma (painel administrativo, checkout), e não aos dados públicos da vitrine. Até abril de 2026, não havia processos específicos sobre scraping do Shopify.

Precedentes jurídicos importantes apoiam o scraping de dados públicos: o caso hiQ v. LinkedIn estabeleceu que coletar dados publicamente acessíveis não viola o CFAA, e Meta v. Bright Data (2024) decidiu que restrições dos TOS só se aplicam quando o usuário está logado.

Boas práticas:

• Extraia apenas dados públicos de produtos
• Não colete dados pessoais ou de clientes
• Respeite o robots.txt e os limites de requisição
• Cumpra GDPR/CCPA se você lidar com qualquer dado pessoal (catálogo de produtos não é dado pessoal)
• Identifique-se com uma string clara de User-Agent
• Extrair dados da sua própria loja Shopify via Admin API sempre é permitido

Para um mergulho mais profundo, veja nosso artigo sobre .

Conclusão e principais aprendizados

O endpoint público /products.json do Shopify torna a extração de dados de ecommerce incrivelmente simples. O fluxo é: adicionar /products.json → buscar com Python → paginar com ?limit=250&page= → achatar com pandas → exportar para CSV ou Excel.

O que este guia traz de diferente de outros:

• Referência completa de campos: saiba exatamente quais dados estão disponíveis (mais de 40 campos em produtos, variantes e imagens) antes de escrever uma única linha de código
• Endpoints adicionais: /collections.json e /meta.json oferecem inteligência de categorias e metadados da loja que nenhum tutorial concorrente cobre
• Técnicas prontas para produção: reutilização de sessão, backoff exponencial, cabeçalhos User-Agent e ?limit=250 para lidar com limites reais
• Exportação correta para CSV/Excel: dados de variantes achatados com pandas, em vez de apenas despejar JSON bruto
• Alternativa sem código: para quem prefere velocidade em vez de flexibilidade de código

Para extrações pontuais ou recorrentes do Shopify sem código, experimente a — o template Shopify Scraper cuida de tudo, da paginação à exportação. Para pipelines de dados personalizados ou scraping em escala em várias lojas, o script em Python deste guia oferece controle total.

Confira nosso para tutoriais em vídeo, ou explore nossos guias sobre e para técnicas relacionadas.

FAQs

É possível extrair qualquer loja Shopify com products.json?

A maioria das lojas Shopify expõe esse endpoint por padrão — nos testes, cerca de 71% retornaram JSON válido. Algumas lojas com configurações personalizadas ou camadas extras de segurança (Cloudflare, setups headless) podem retornar 404 ou bloquear a requisição. A checagem rápida: acesse {store-url}/products.json no navegador. Se aparecer JSON, está tudo certo.

É legal fazer scraping de lojas Shopify?

Dados públicos de produtos (preços, títulos, imagens, descrições) geralmente podem ser acessados, e precedentes como hiQ v. LinkedIn dão suporte à coleta de informações publicamente disponíveis. Ainda assim, verifique sempre os Termos de Serviço da loja específica e as leis locais. Não colete dados pessoais ou de clientes, e respeite os limites de requisição.

Quantos produtos você consegue extrair de uma loja Shopify?

Não existe um limite total rígido. A paginação com ?limit=250&page= permite recuperar todo o catálogo. Em lojas muito grandes (25.000+ produtos), use reutilização de sessão e pausas para evitar limites de requisição. O endpoint /meta.json pode informar a contagem exata de produtos logo no início, para você saber quantas páginas esperar.

Qual é a diferença entre products.json e a Shopify Admin API?

/products.json é um endpoint público — sem autenticação, apenas leitura de dados de produtos, acessível a qualquer pessoa. A Admin API exige tokens de acesso do proprietário da loja e fornece pedidos, quantidades de estoque, dados de clientes e permissão de escrita. Se você precisa de dados de vendas ou quantidades reais de estoque, precisa de acesso à Admin API (ou seja, ser o proprietário da loja ou ter permissão).

Posso extrair Shopify sem Python?

Com certeza. Ferramentas como o permitem extrair lojas Shopify por meio de uma extensão do Chrome, sem código. Ele trata a paginação automaticamente e exporta direto para CSV, Excel, Google Sheets, Airtable ou Notion. Para desenvolvedores que preferem outras linguagens, o mesmo endpoint /products.json funciona com JavaScript, Ruby, Go — qualquer linguagem capaz de fazer requisições HTTP e parsear JSON.

Saiba mais