---
title: "Como fazer scraping de lojas do Shopify com Python"
slug: how-to-scrape-shopify-stores
date: 2025-06-10T08:46:02+00:00
modified: 2025-11-04T08:49:18+00:00
permalink: https://brightdata.com.br/blog/dados-do-site/how-to-scrape-shopify-stores
type: blog
---
[ Blog ](https://brightdata.com.br/blog "Blog") / [Dados do site](https://brightdata.com.br/blog/dados-do-site)
[Dados do site](https://brightdata.com.br/blog/dados-do-site)
# Como fazer scraping de lojas do Shopify com Python
Simplifique a extração de dados do Shopify aproveitando o products.json e métodos eficazes de raspagem.
9 min de leitura
[  ](https://brightdata.com/blog/authors/jake-nulty)
[Jake Nulty
Technical Writer
](https://brightdata.com/blog/authors/jake-nulty)
À primeira vista, as lojas do Shopify representam um dos desafios mais difíceis na extração de dados. O produto abaixo representa uma listagem típica do Shopify. Os dados são tão aninhados quanto possível.
```none
```
**Não é impossível extrair dados do HTML acima, mas há uma maneira mais fácil.**
## Páginas de destino da Shopify
Em https://hiutdenim [.co.uk/,](https://hiutdenim.co.uk/) a página de destino contém algumas informações sobre o produto, mas são relativamente limitadas. Role a página para baixo o suficiente e você chegará lá.
À primeira vista, parece que você precisará extrair cada link para cada seção e, em seguida, obter e analisar todas essas páginas diferentes. As lojas da Shopify não seguem os métodos tradicionais envolvidos na [coleta de dados de comércio eletrônico](/blog/procedimentos/ecommerce-web-scraping-guide) devido aos layouts de página exclusivos. No entanto, há outra maneira.
## Páginas JSON da Shopify
Você leu o título corretamente. Podemos obter todos os produtos da loja como um objeto JSON por padrão. Não precisamos nem mesmo do [BeautifulSoup](/blog/procedimentos/beautiful-soup-web-scraping) ou do [Selenium](/blog/procedimentos/using-selenium-for-web-scraping).
Só precisamos adicionar `/products.json` à nossa URL. Todo site da Shopify é construído com base em um arquivo `products.json`.
Se pudermos solicitar esse conteúdo (o que é possível), poderemos obter todos os dados que desejarmos. Depois de obtê-los, só precisamos decidir quais dados queremos manter. Você pode verificar isso no site que estamos usando [aqui](https://hiutdenim.co.uk/products.json).
## Raspagem do Shopify em Python
Agora que sabemos o que estamos procurando, essa tarefa assustadora se torna muito menos difícil. Como estamos lidando apenas com dados JSON, temos uma dependência que precisamos instalar, [o Python Requests](/blog/dados-do-site/python-requests-guide).
```none
pip install requests
```
### Funções individuais
Vamos dar uma olhada nas partes individuais do código. Temos três partes separadas que compõem o raspador.
Esta é a nossa função mais importante. Ela realmente executa a lógica de raspagem.
```none
def scrape_shopify(url, retries=2):
"""scrape a shopify store"""
json_url = f"{url}products.json"
items = []
success = False
while not success and retries > 0:
response = requests.get(json_url)
try:
response.raise_for_status()
products = response.json()["products"]
for product in products:
product_data = {
"title": product["title"],
"tags": product["tags"],
"id": product["id"],
"variants": product["variants"],
"images": product["images"],
"options": product["options"]
}
items.append(product_data)
success = True
except requests.RequestException as e:
print(f"Error during request: {e}, failed to get {json_url}")
except KeyError as key_error:
print(f"Failed to parse json: {key_error}")
except json.JSONDecodeError as e:
print(f"json error: {e}")
except Exception as e:
print(f"Unforeseen error: {e}")
retries-=1
print(f"Retries left: ", retries)
return items
```
- Primeiro, anexamos `products.json` à nossa url: `json_url = f"{url}products.json"`.
- Inicializamos um array vazio, `items`. À medida que coletamos nossos itens, nós os anexamos a esse array. Quando a coleta for concluída, retornaremos o array de itens analisados.
- Desde que recebamos uma boa resposta, recuperamos a chave `"products"` para obter todos os nossos produtos.
- Extraímos várias partes de dados de cada produto para criar um `dict`, `product_data`.
- `product_data` é anexado à matriz.
- Esse processo se repete até que tenhamos analisado todos os produtos da página.
Agora temos uma função que executa nosso scrape e retorna uma matriz de produtos. Agora, precisamos de uma função que pegue essa matriz de produtos e a grave em um arquivo. Poderíamos usar CSV aqui, mas como essa estrutura fica bastante aninhada, usaremos JSON. Ele oferece suporte a estruturas de dados mais flexíveis para uso e análise posteriores.
```none
def json2file(json_data, filename):
"""save json data to a file"""
try:
with open(filename, "w", encoding="utf-8") as file:
json.dump(json_data, file, indent=4)
print(f"Data successfully saved: {filename}")
except Exception as e:
print(f"failed to write json data to {filename}, ERROR: {e}")
```
Esse é o código real que vamos usar. Agora, criamos um bloco `principal` para executar nosso scraper.
```none
if __name__ == "__main__":
shop_url = "https://hiutdenim.co.uk/"
items = scrape_shopify(shop_url)
json2file(items, "output.json")
```
### Colocando tudo junto
Quando juntamos tudo, nosso coletor de dados tem a seguinte aparência. O que parecia ser um projeto de análise complexo agora é um coletor de dados totalmente funcional que ocupa apenas cerca de 50 linhas de código.
```none
import requests
import json
def json2file(json_data, filename):
"""save json data to a file"""
try:
with open(filename, "w", encoding="utf-8") as file:
json.dump(json_data, file, indent=4)
print(f"Data successfully saved: {filename}")
except Exception as e:
print(f"failed to write json data to {filename}, ERROR: {e}")
def scrape_shopify(url, retries=2):
"""scrape a shopify store"""
json_url = f"{url}products.json"
items = []
success = False
while not success and retries > 0:
response = requests.get(json_url)
try:
response.raise_for_status()
products = response.json()["products"]
for product in products:
product_data = {
"title": product["title"],
"tags": product["tags"],
"id": product["id"],
"variants": product["variants"],
"images": product["images"],
"options": product["options"]
}
items.append(product_data)
success = True
except requests.RequestException as e:
print(f"Error during request: {e}, failed to get {json_url}")
except KeyError as key_error:
print(f"Failed to parse json: {key_error}")
except json.JSONDecodeError as e:
print(f"json error: {e}")
except Exception as e:
print(f"Unforeseen error: {e}")
retries-=1
return items
if __name__ == "__main__":
shop_url = "https://hiutdenim.co.uk/"
items = scrape_shopify(shop_url)
json2file(items, "output.json")
```
### Os dados de retorno
Nossos dados são retornados em uma matriz de objetos JSON. Cada produto contém uma lista de `variantes` e `imagens`. Isso seria muito difícil de representar com precisão em CSV. O snippet que você vê abaixo é um único produto de nosso scrape.
```none
{
"title": "The Valerie - Organic Denim",
"tags": [
"The Valerie",
"Women"
],
"id": 14874183401848,
"variants": [
{
"id": 54902462808440,
"title": "UK10-29 / 30",
"option1": "UK10-29",
"option2": "30",
"option3": null,
"sku": null,
"requires_shipping": true,
"taxable": true,
"featured_image": null,
"available": true,
"price": "220.00",
"grams": 0,
"compare_at_price": null,
"position": 1,
"product_id": 14874183401848,
"created_at": "2026-01-21T14:04:58+00:00",
"updated_at": "2026-02-12T17:17:54+00:00"
},
{
"id": 54902462939512,
"title": "UK12-30 / 32",
"option1": "UK12-30",
"option2": "32",
"option3": null,
"sku": null,
"requires_shipping": true,
"taxable": true,
"featured_image": null,
"available": true,
"price": "220.00",
"grams": 0,
"compare_at_price": null,
"position": 2,
"product_id": 14874183401848,
"created_at": "2026-01-21T14:04:58+00:00",
"updated_at": "2026-02-12T17:17:54+00:00"
},
{
"id": 54902463070584,
"title": "UK14-32 / 28",
"option1": "UK14-32",
"option2": "28",
"option3": null,
"sku": null,
"requires_shipping": true,
"taxable": true,
"featured_image": null,
"available": true,
"price": "220.00",
"grams": 0,
"compare_at_price": null,
"position": 3,
"product_id": 14874183401848,
"created_at": "2026-01-21T14:04:58+00:00",
"updated_at": "2026-02-12T17:17:54+00:00"
},
{
"id": 54902463496568,
"title": "UK18-36 / 30",
"option1": "UK18-36",
"option2": "30",
"option3": null,
"sku": null,
"requires_shipping": true,
"taxable": true,
"featured_image": null,
"available": true,
"price": "220.00",
"grams": 0,
"compare_at_price": null,
"position": 4,
"product_id": 14874183401848,
"created_at": "2026-01-21T14:04:58+00:00",
"updated_at": "2026-02-12T17:17:54+00:00"
}
],
"images": [
{
"id": 31828166443078,
"created_at": "2024-06-17T12:05:49+01:00",
"position": 1,
"updated_at": "2024-06-17T12:05:50+01:00",
"product_id": 14874183401848,
"variant_ids": [],
"src": "https://cdn.shopify.com/s/files/1/0065/4242/files/HDC_0723_JapanInd_Valerie_45_3_c547ba8a-681b-4486-8cd7-884000e43302.jpg?v=1718622350",
"width": 4000,
"height": 4000
},
{
"id": 31828166541382,
"created_at": "2024-06-17T12:05:49+01:00",
"position": 2,
"updated_at": "2024-06-17T12:05:51+01:00",
"product_id": 14874183401848,
"variant_ids": [],
"src": "https://cdn.shopify.com/s/files/1/0065/4242/files/HDC_0723_JapanInd_Valerie_Back_2_5909adb3-c2ab-4810-8b66-a486e8d827a8.jpg?v=1718622351",
"width": 4000,
"height": 4000
},
{
"id": 31828166508614,
"created_at": "2024-06-17T12:05:49+01:00",
"position": 3,
"updated_at": "2024-06-17T12:05:51+01:00",
"product_id": 14874183401848,
"variant_ids": [],
"src": "https://cdn.shopify.com/s/files/1/0065/4242/files/HDC_0723_JapanInd_Valerie_Front_3_4316907a-9fd8-4649-894c-4028877370e1.jpg?v=1718622351",
"width": 4000,
"height": 4000
},
{
"id": 31828166475846,
"created_at": "2024-06-17T12:05:49+01:00",
"position": 4,
"updated_at": "2024-06-17T12:05:51+01:00",
"product_id": 14874183401848,
"variant_ids": [],
"src": "https://cdn.shopify.com/s/files/1/0065/4242/files/HDC_0723_JapanInd_Valerie_Side_2_ea21477b-c1ba-4c8a-b75e-75c6427b4977.jpg?v=1718622351",
"width": 4000,
"height": 4000
}
],
"options": [
{
"name": "Waist",
"position": 1,
"values": [
"UK10-29",
"UK12-30",
"UK14-32",
"UK18-36"
]
},
{
"name": "Leg Length",
"position": 2,
"values": [
"30",
"32",
"28"
]
}
]
},
```
## Técnicas avançadas
O mundo não é perfeito e é possível que você tenha dificuldades com o raspador acima. Talvez você precise raspar várias páginas ou, às vezes, seu raspador pode ser bloqueado.
### Paginação
Ao fazer o scraping de lojas maiores, você frequentemente encontrará lojas com resultados paginados. Para lidar com a paginação, primeiro, queremos o máximo de resultados por página. Podemos adicionar o seguinte parâmetro de consulta: `page=` para controlar nossas páginas de resultados.
Podemos modificar ligeiramente nossa função de raspagem para obter uma página no URL e o número da página.
```none
def scrape_shopify(url, retries=2):
"""scrape a shopify store"""
json_url = f"{url}products.json"
```
Em seguida, podemos ajustar nosso `principal` para refletir essas mudanças.
```none
if __name__ == "__main__":
shop_url = "https://www.allbirds.com/"
PAGES = 3
for page in range(PAGES):
items = scrape_shopify(shop_url, page=page+1)
json2file(items, f"page{page}output.json")
```
### Integração de proxy
Às vezes, pode ser necessário usar um [serviço de proxy](/proxy-types) para evitar que seu scraper seja bloqueado. Com nossos [proxies do Shopify](/solutions/shopify-proxy), é tão simples quanto criar um URL com suas credenciais.
```none
PROXY_URL = "http://brd-customer--zone-:@brd.superproxy.io:33335"
proxies = {
"http": PROXY_URL,
"https": PROXY_URL
}
response = requests.get(json_url, proxies=proxies, verify="brd.crt")
```
## Outras soluções da Bright Data
A Bright Data oferece alternativas poderosas e prontas para uso que eliminam a necessidade de criar raspadores complexos do zero. Use nosso [Shopify Scraper totalmente otimizado](/products/web-scraper/shopify) para extrair dados sem problemas ou acesse nossa [extensa biblioteca de conjuntos de dados pré-coletados](/products/datasets) disponíveis em vários formatos para iniciar seus projetos imediatamente.
## Conclusão
A extração de dados de uma loja da Shopify não precisa ser uma tarefa impossível. Simplesmente aproveitando a API com `products.json`, você pode coletar uma grande quantidade de dados detalhados de produtos rapidamente. Você não precisa nem usar um analisador de HTML! Se desejar, você pode reduzir o tempo de desenvolvimento com um de nossos raspadores pré-fabricados ou pode começar a trabalhar imediatamente com nossos conjuntos de dados.
Todos os nossos produtos são fornecidos com uma avaliação gratuita. Inscreva-se agora!
Contate-nosTeste grátis
Índice
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Como+fazer+scraping+de+lojas+do+Shopify+com+Python&u=https://brightdata.com.br/blog/dados-do-site/how-to-scrape-shopify-stores) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Como+fazer+scraping+de+lojas+do+Shopify+com+Python&url=https://brightdata.com.br/blog/dados-do-site/how-to-scrape-shopify-stores) [ ](http://www.reddit.com/submit?title=Como+fazer+scraping+de+lojas+do+Shopify+com+Python&url=https://brightdata.com.br/blog/dados-do-site/how-to-scrape-shopify-stores)
## Você também pode estar interessado em
[  ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI
Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA.
09-Sep-2026
14 min de leitura
](https://brightdata.com.br/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax")
[Dados do site
Antonello Zanini
Technical Writer
### Scraping de Dados Multimodal com MiniMax
Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web.
09-Sep-2026
5 min de leitura
](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas")
[AI
Daniel Shashko
Web Data & AI Expert
### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas
As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox.
06-Sep-2026
24 min de leitura
](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)
