Como Extrair Dados de Produtos da Home Depot Com um Navegador de Agente

npm install -g scrapeless-scraping-browser

scrapeless-scraping-browser config set apiKey seu_token_api_aqui
scrapeless-scraping-browser config get apiKey   # verifique

export SCRAPELESS_API_KEY=seu_token_api_aqui

{
  "productId": "204279858",
  "productUrl": "https://www.homedepot.com/p/DEWALT-20V-MAX-Cordless-1-2-in-Drill-Driver-2-20V-1-3Ah-Batteries-Charger-and-Bag-DCD771C2/204279858",
  "productName": "DEWALT 20V MAX Cordless 1/2 in. Drill/Driver, (2) 20V 1.3Ah Batteries, Charger and Bag DCD771C2",
  "brand": "DEWALT",
  "sku": "1000014677",
  "modelNumber": "DCD771C2",
  "overallRating": 4.7,
  "totalReviews": 11168,
  "reviewsReturned": 10,
  "reviews": [
    {
      "title": "Ótima ferramenta!",
      "text": "Estou usando isso há duas semanas e vale cada centavo. A qualidade é excepcionalmente nítida...",
      "rating": 5,
      "reviewer": { "name": "kevein" },
      "time": null,
      "original_source": { "name": "homedepot.com" }
    },
    {
      "title": null,
      "text": "Comprei a furadeira/driver Dewalt 20v max para substituir uma antiga furadeira sem fio Craftsman...",
      "rating": 5,
      "reviewer": { "name": "DIYer_Bill" },
      "time": null,
      "original_source": { "name": "homedepot.com" }
    }
    // ... 8 mais avaliações com o mesmo formato
  ]
}

SESSION=$(scrapeless-scraping-browser new-session \
  --name "dados-do-produto-homedepot" \
  --ttl 1800 \
  --recording true \
  --proxy-country US \
  --json | jq -r '.data.taskId')

echo "Sessão: $SESSION"

SESSION=$(scrapeless-scraping-browser new-session \
  --name "dados-do-produto-homedepot" --ttl 1800 --recording true \
  --proxy-country US --json \
  | grep -oE '"taskId":"[^"]*"' | cut -d'"' -f4)

PRODUCT_ID="204279858"

PRODUCT_SLUG="DEWALT-20V-MAX-Cordless-1-2-in-Drill-Driver-2-20V-1-3Ah-Batteries-Charger-and-Bag-DCD771C2"
PDP_URL="https://www.homedepot.com/p/$PRODUCT_SLUG/$PRODUCT_ID"

scrapeless-scraping-browser --session-id $SESSION open "$PDP_URL"
# Breve pausa para que a próxima espera não seja resolvida na pré-aquecida
# chrome://new-tab-page/ antes que a navegação se comprometa.
scrapeless-scraping-browser --session-id $SESSION wait 1500
# Aguarde pelo título do produto H1 — os blocos JSON-LD são renderizados no servidor em
# o mesmo HTML estático e são garantidamente presentes assim que o H1 está visível.
# (Não espere no `script[type="application/ld+json"]` diretamente — `wait` padrão
# para o estado "visível", e elementos `<script>` nunca são visíveis.)
scrapeless-scraping-browser --session-id $SESSION wait 'h1'

scrapeless-scraping-browser --session-id $SESSION eval '
  (() => {
    const ld = [...document.querySelectorAll("script[type=\"application/ld+json\"]")]
      .map((s) => { try { return JSON.parse(s.textContent); } catch { return null; } })
      .filter(Boolean);
    const product = ld.find((o) => o["@type"] === "Product");
    if (!product) return JSON.stringify({ error: "sem Product JSON-LD nesta página" });

    const productId =
      product.productID || product.sku ||
      location.pathname.match(/\/(\d+)(?:\/\d+)?(?:[/?#]|$)/)?.[1] || null;

    const offers = Array.isArray(product.offers) ? product.offers[0] : product.offers || null;
    const offerPrice = offers
      ? (offers.price ?? offers.priceSpecification?.price ?? offers.lowPrice ?? null)
      : null;
    const availability = offers?.availability
      ? String(offers.availability).replace(/^https?:\/\/schema\.org\//, "")
      : null;

    const images = []
      .concat(product.image || [])
      .flat()
      .filter(Boolean);

    const reviews = (Array.isArray(product.review) ? product.review : product.review ? [product.review] : [])
      .map((r) => ({
        title: r.headline || null,
        text: r.reviewBody || null,
        rating: Number(r.reviewRating?.ratingValue) || null,
        reviewer: { name: r.author?.name || null },
        time: r.datePublished || null,
        original_source: { name: "homedepot.com" },
      }));

    return JSON.stringify({
      productId,
      productUrl: location.href,
      productName: product.name,
      brand: product.brand?.name || product.brand || null,
      sku: product.sku || null,
      modelNumber: product.model || null,
      gtin: product.gtin13 || product.gtin14 || product.gtin12 || product.gtin8 || product.gtin || null,
      mpn: product.mpn || null,
      category: product.category || null,
      description: product.description || null,
      color: product.color || null,
      image: images[0] || null,
      images,
      offers: {
        price: offerPrice != null ? Number(offerPrice) : null,
        currency: offers?.priceCurrency || null,
        availability,
        priceValidUntil: offers?.priceValidUntil || null,
        itemCondition: offers?.itemCondition
          ? String(offers.itemCondition).replace(/^https?:\/\/schema\.org\//, "")
          : null,
        seller: offers?.seller?.name || null,
      },
      overallRating: Number(product.aggregateRating?.ratingValue) || null,
      totalReviews: Number(product.aggregateRating?.reviewCount) || null,
      reviewsReturned: reviews.length,
      reviews,
    });
  })()
'

Execute um passe de descoberta `get html` contra a região de preço do PDP primeiro, confirme os nomes de âncoras ativos, depois aperte os seletores `eval` para o que a página realmente exibe. Os nomes de classe mudam; padrões de `data-testid` e `aria-label` são a superfície estável.

```bash
# A sessão ainda está no PDP da Etapa 2. Aguarde a região de preço renderizar,
# depois examine o HTML circundante para confirmar âncoras.
scrapeless-scraping-browser --session-id $SESSION wait '[data-testid*="price" i], [class*="price" i], [data-component*="Price"]'
scrapeless-scraping-browser --session-id $SESSION get html '[data-testid*="price" i], [data-testid*="fulfillment" i]'

scrapeless-scraping-browser --session-id $SESSION eval '
  (() => {
    const text = (el) => (el ? el.textContent.replace(/\s+/g, " ").trim() : null);
    const number = (s) => {
      if (!s) return null;
      const m = String(s).replace(/,/g, "").match(/-?\d+(?:\.\d+)?/);
      return m ? Number(m[0]) : null;
    };

    const priceText =
      text(document.querySelector("[data-testid*=\"price\" i]")) ||
      text(document.querySelector("[class*=\"price\" i]"));
    const wasPriceText = text(document.querySelector(
      "[data-testid*=\"was-price\" i], [class*=\"was-price\" i], [data-testid*=\"strike\" i]"
    ));
    const onSale = !!wasPriceText && priceText !== wasPriceText;

    const promotion = text(document.querySelector("[data-testid*=\"promo\" i], [data-testid*=\"saving\" i]"));

    const fulfillment = [...document.querySelectorAll(
      "[data-testid*=\"fulfillment\" i] button, [aria-label*=\"Enviar\" i], [aria-label*=\"Retirada\" i], [aria-label*=\"Entrega\" i]"
    )].map((btn) => {
      const label = btn.getAttribute("aria-label") || text(btn);
      return label ? { option: label, available: !btn.matches("[disabled], [aria-disabled=\"true\"]") } : null;
    }).filter(Boolean);

    const availabilityText = text(document.querySelector(
      "[data-testid*=\"availability\" i], [data-testid*=\"in-stock\" i]"
    ));

    const heroImg = document.querySelector(
      "img[data-testid*=\"main-image\" i], [data-testid*=\"image-gallery\" i] img, picture img"
    );

    const features = [...document.querySelectorAll(
      "[data-testid*=\"feature\" i] li, [class*=\"feature\" i] li, [data-testid*=\"highlights\" i] li"
    )].map(text).filter(Boolean).slice(0, 20);

    const specs = Object.fromEntries(
      [...document.querySelectorAll("[data-testid*=\"specs\" i] tr, [class*=\"specs\" i] tr")]
        .map((row) => {
          const cells = [...row.querySelectorAll("th, td")].map(text);
          return cells.length >= 2 ? [cells[0], cells.slice(1).join(" ")] : null;
        })
        .filter(Boolean)
    );

    return JSON.stringify({
      productUrl: location.href,
      price: number(priceText),
      priceText,
      wasPrice: number(wasPriceText),
      onSale,
      promotion,
      currency: "USD",
      fulfillment,
      availabilityText,
      image: heroImg?.currentSrc || heroImg?.src || null,
      features,
      specs,
    });
  })()
'

QUERY="furadeira sem fio"
# Codifique espaços na consulta (Home Depot usa codificação padrão de URL)
SEARCH_URL="https://www.homedepot.com/s/${QUERY// /%20}"

scrapeless-scraping-browser --session-id $SESSION open "$SEARCH_URL"
# As páginas de busca têm uma renderização em duas fases: um esqueleto de espaço reservado React com um
# único cartão monta primeiro, depois a grade real de ~24 cartões se preenche. Um simples
# `wait '[data-testid*="product-pod" i]'` pode resolver no espaço reservado, então
# o extrator roda contra uma grade vazia. Aguarde pela grade real
# (≥ 5 cartões) em vez de qualquer correspondência única.
scrapeless-scraping-browser --session-id $SESSION wait 3000
scrapeless-scraping-browser --session-id $SESSION eval \
  'document.querySelectorAll("[data-testid*=\"product-pod\" i], [data-pod-position]").length >= 5'

scrapeless-scraping-browser --session-id $SESSION eval '
  (() => {
    const text = (el) => (el ? el.textContent.replace(/\s+/g, " ").trim() : null);
    const number = (s) => {
      if (!s) return null;
```javascript
const m = String(s).replace(/,/g, "").match(/-?\d+(?:\.\d+)?/);
      return m ? Number(m[0]) : null;
    };
    const cards = [...document.querySelectorAll("[data-testid*=\"product-pod\" i], [data-pod-position]")];
    const results = cards.map((c) => {
      const link = c.querySelector("a[href*=\"/p/\"]");
      const href = link?.getAttribute("href");
      const productId = href?.match(/\/(\d{6,})(?:[/?#]|$)/)?.[1] || null;
      const titleEl = c.querySelector("[data-testid*=\"product-title\" i], [class*=\"product-title\" i], h2, h3");
      const ratingEl = c.querySelector("[aria-label*=\"em\" i]");
      const reviewCountEl = c.querySelector("[data-testid*=\"review-count\" i], [class*=\"review-count\" i]");
      const priceEl = c.querySelector("[data-testid*=\"price\" i], [class*=\"price\" i]");
      const brandEl = c.querySelector("[data-testid*=\"brand\" i], [class*=\"brand\" i]");
      const img = c.querySelector("img");
      return {
        productId,
        productUrl: href ? new URL(href, location.origin).href : null,
        title: text(titleEl),
        brand: text(brandEl),
        price: number(text(priceEl)),
        priceText: text(priceEl),
        rating: number(ratingEl?.getAttribute("aria-label")),
        reviewCount: number(text(reviewCountEl)),
        image: img?.currentSrc || img?.src || null,
      };
    }).filter((r) => r.productId || r.productUrl);
    const offset = Number(new URLSearchParams(location.search).get("Nao") || 0);
    return JSON.stringify({
      query: location.href,
      page: Math.floor(offset / 24) + 1,
      pageSize: results.length,
      results,
    });
  })()
'

for offset in 0 24 48 72 96; do
  scrapeless-scraping-browser --session-id $SESSION open "$SEARCH_URL?Nao=$offset"
  scrapeless-scraping-browser --session-id $SESSION wait 1500
  scrapeless-scraping-browser --session-id $SESSION wait '[data-testid*="product-pod" i], [data-pod-position]'
  scrapeless-scraping-browser --session-id $SESSION eval '/* extrator de listagens iguais */' \
    > "search-page-$((offset / 24 + 1)).json"
done

CEP="90015"

# 1. Abra a PDP e mostre as referências de acessibilidade para o seletor de localização.
scrapeless-scraping-browser --session-id $SESSION open \
  "https://www.homedepot.com/p/$PRODUCT_SLUG/$PRODUCT_ID"
scrapeless-scraping-browser --session-id $SESSION wait 1500
scrapeless-scraping-browser --session-id $SESSION wait '[data-testid*="store-locator" i], [aria-label*="store" i]'
scrapeless-scraping-browser --session-id $SESSION snapshot -i > /tmp/pdp-refs.txt

# 2. Clique em "Alterar Loja" / "Minha Loja" → preencha o CEP → confirme.
#    Ajuste as referências @e<n> abaixo conforme o que o instantâneo retorna.
scrapeless-scraping-browser --session-id $SESSION click @e15            # Alterar Loja
scrapeless-scraping-browser --session-id $SESSION wait 800
scrapeless-scraping-browser --session-id $SESSION fill @e22 "$CEP"      # Entrada CEP
scrapeless-scraping-browser --session-id $SESSION click @e25            # Pesquisar / Confirmar
scrapeless-scraping-browser --session-id $SESSION wait 1500
scrapeless-scraping-browser --session-id $SESSION wait '[data-testid*="fulfillment" i], [data-testid*="availability" i]'

# 3. Extraia a disponibilidade por loja + o distintivo da loja.
scrapeless-scraping-browser --session-id $SESSION eval '
  (() => {
    const text = (el) => (el ? el.textContent.replace(/\s+/g, " ").trim() : null);
    return JSON.stringify({
      productUrl: location.href,
      store: text(document.querySelector("[data-testid*=\"store-name\" i], [data-testid*=\"my-store\" i]")),
      zip: "'$CEP'",

availabilityText: texto(document.querySelector("[data-testid*=\"availability\" i], [data-testid*=\"in-stock\" i]")),
      pickupEta: texto(document.querySelector("[data-testid*=\"pickup\" i], [aria-label*=\"Pickup\" i]")),
      stockCount: texto(document.querySelector("[data-testid*=\"stock-count\" i], [class*=\"stock-count\" i]")),
    });
  })()
'

O estado da loja é preservado em cookies pelo restante da sessão — chamadas subsequentes (a avaliação de campos hidratados da Etapa 3, o extrator de resenhas renderizadas da Etapa 6, o fluxo de classificação da Etapa 7) retornam a visualização regional sem precisar reabrir o modal.

**Fallback definido por cookies.** Quando o modal do seletor de localização não é acessível (bloqueador de pop-up, variante A/B, WAF transitório), o mesmo resultado está disponível via cookies — `THD_LOCSTORE` / `THD_PERSIST` carregam o id da loja e o CEP. Defina-os via `scrapeless-scraping-browser cookies set` e o próximo `open` retorna o PDP de contexto da loja sem o fluxo de cliques.

---

## Etapa 6 — Avaliações 11+ via o carrossel renderizado

Quando o fluxo de trabalho precisa de mais do que os 10 principais do JSON-LD (corpo completo de avaliações, sort/filter aplicados, intervalo de datas personalizado), o widget de avaliação renderizado é a superfície. As avaliações estão em `/p/reviews/<slug>/<productId>/<page>` e dentro do carrossel on-PDP; ambos renderizam através do mesmo micro-frontend de avaliações de produtos paginados em `assets.thdstatic.com/experiences/paginated-product-reviews/*`.

Conduza o fluxo descobrir → extrair:

```bash
REVIEWS_URL="https://www.homedepot.com/p/reviews/$PRODUCT_SLUG/$PRODUCT_ID/1"

scrapeless-scraping-browser --session-id $SESSION open "$REVIEWS_URL"
scrapeless-scraping-browser --session-id $SESSION wait 1500
# networkidle NÃO se estabiliza no Home Depot — aguarde pelos âncoras do cartão de avaliação.
scrapeless-scraping-browser --session-id $SESSION wait "#reviews, [itemprop='review'], [data-testid*='review' i]"

# Dê uma olhada no HTML da região de avaliações para confirmar os âncoras
scrapeless-scraping-browser --session-id $SESSION get html "#reviews, [data-component*='Review' i]"

scrapeless-scraping-browser --session-id $SESSION eval '
  (() => {
    const texto = (el) => (el ? el.textContent.replace(/\s+/g, " ").trim() : null);
    const numero = (v) => {
      if (v == null) return null;
      const m = String(v).replace(/,/g, "").match(/-?\d+(?:\.\d+)?/);
      return m ? Number(m[0]) : null;
    };
    const unico = (xs) => [...new Set(xs.filter(Boolean))];

    const productId =
      location.pathname.match(/\/(\d+)(?:\/\d+)?(?:[/?#]|$)/)?.[1] || null;

    const root =
      document.querySelector("#reviews") ||
      document.querySelector("[data-component*=\"Review\" i]") ||
      document.querySelector("[data-testid*=\"review\" i]") ||
      document.body;

    const cards = [...root.querySelectorAll(
      "[itemprop=\"review\"], [data-testid*=\"review\" i], article, li"
    )].filter((c) => {
      const bodyStr = texto(c) || "";
      const hasRating = !!c.querySelector("[aria-label*=\"out of\" i]");
      const looksReviewish = /(verificado|recomendar|útil|avaliação|comprado)/i.test(bodyStr);
      return bodyStr.length > 40 && (hasRating || looksReviewish);
    });

    const reviews = cards.map((c) => {
      const bodyStr = texto(c) || "";
      const ratingLabel =
        c.querySelector("[aria-label*=\"out of\" i]")?.getAttribute("aria-label") ||
        texto(c.querySelector("[data-testid*=\"rating\" i]"));
      const dateEl = c.querySelector("time, [datetime], [data-testid*=\"date\" i]");
      const helpfulText = unico(
        [...c.querySelectorAll("button, [aria-label*=\"útil\" i]")]
          .map((el) => el.getAttribute("aria-label") || texto(el))
      ).join(" ");
      return {
        id: c.getAttribute("id") || c.getAttribute("data-review-id") || null,
        title: texto(c.querySelector("[data-testid*=\"title\" i], h3, h4")),
        text: texto(c.querySelector("[data-testid*=\"body\" i], p")),
        rating: numero(ratingLabel),
        isRecommended: /recomendar/i.test(bodyStr)
          ? !/não recomendar|não recomendaria/i.test(bodyStr) : null,
        badges: unico(
          [...c.querySelectorAll("[data-testid*=\"badge\" i], [class*=\"badge\" i]")].map(texto)
            .concat(bodyStr.match(/Comprador Verificado|Comprador Verificado|Pro|Escolha da Equipe|Incentivado/gi) || [])
        ),
        reviewer: { name: texto(c.querySelector("[data-testid*=\"author\" i], [class*=\"author\" i]")) },
        time: dateEl?.getAttribute("datetime") || texto(dateEl),
        original_source: { name: "homedepot.com" },

return JSON.stringify({ productId, productUrl: location.href, reviewsReturned: reviews.length, reviews });

O extrator de DOM renderizado é o caminho para a paginação de avaliações (Passo 8), aplicando ordenação/filtro (Passo 7), e qualquer vez que o fluxo de trabalho precisar de avaliações 11+. Trate campos ausentes como `null` ou `[]` em vez de descartar a chave — isso mantém os pipelines a montante estáveis quando o Home Depot rotaciona um modelo de cartão de avaliação.

> **Esquema por avaliação:** `id`, `titulo`, `texto`, `classificação`, `insígnias`, `nome_reviewer` (aninhado), `tempo`, `nome_original_source` (aninhado), `imagens[].link` (array de objetos), `total_feedback_positivo`, `total_feedback_negativo`, além dos extras Scrapeless `isRecommended` (booleano derivado do texto da avaliação) e `verificado` (booleano derivado do texto da insígnia). Mantenha campos ausentes como `null` ou `[]` para que os consumidores a montante permaneçam estáveis entre as rotações do DOM.

Se a passagem de avaliação renderizada retornar zero cards mesmo após a espera, o micro-front-end não foi totalmente hidratado; tente a espera novamente, tente com uma nova sessão se `Acesso Negado` retornou, ou recorra ao JSON-LD dos 10 melhores do Passo 2 mais o caminho de paginação GraphQL (`/federation-gateway/graphql?opname=reviewSentiments`) para consultas mais profundas.

---

## Passo 7 — Ordenar e filtrar avaliações pela interface

O Home Depot expõe opções de ordenação (mais recente, maior classificação, menor classificação, mais útil, apenas avaliações com fotos) na página de avaliações. Dirija esses controles dentro da mesma sessão persistente — o instantâneo → a coreografia de clique preserva cookies e estado aplicado.

> Os refs `@e34` / `@e35` / `@e36` / `@e41` no trecho são espaços reservados — o instantâneo `scrapeless -i` atribui refs dinamicamente por renderização de página. Capture o instantâneo primeiro, encontre as linhas para os botões de dropdown de ordenação e filtragem, e substitua os números reais antes de executar a sequência de clique.

```bash
# Superfície de referências de acessibilidade para controles interativos
scrapeless-scraping-browser --session-id $SESSION snapshot -i > /tmp/reviews-refs.txt

# Identifique os refs do botão de dropdown de ordenação / filtro do instantâneo, em seguida, clique.
# Em uma página típica de avaliações do Home Depot, esses aparecem como algo como:
#   @e34 [botão] "Ordenar por: Mais Útil"
#   @e35 [botão] "Apenas Fotos"
#   @e36 [botão] "Comprador Verificado"
# Ajuste os números @ref abaixo para o que o instantâneo retornar.

scrapeless-scraping-browser --session-id $SESSION click @e34   # abrir dropdown de ordenação
scrapeless-scraping-browser --session-id $SESSION wait 800
scrapeless-scraping-browser --session-id $SESSION snapshot -i > /tmp/sort-options.txt
scrapeless-scraping-browser --session-id $SESSION click @e41   # opção "Mais Recente"
scrapeless-scraping-browser --session-id $SESSION wait 1500
scrapeless-scraping-browser --session-id $SESSION wait "#reviews, [data-component*='Review' i]"

# Reexecutar a extração após a região de avaliação ser renderizada novamente
scrapeless-scraping-browser --session-id $SESSION eval '/* mesmo corpo de extração de avaliação do Passo 6 */'

for page in $(seq 1 5); do
  scrapeless-scraping-browser --session-id $SESSION eval '/* extrair esquema de avaliação */' \
    > "reviews-page-$page.json"

  # Clique no controle de paginação "Próximo" visível
  scrapeless-scraping-browser --session-id $SESSION eval '
    (() => {
      const next = [...document.querySelectorAll("a, button")]
        .find((el) => /próximo/i.test(el.getAttribute("aria-label") || el.textContent || ""));
      if (!next) return false;
      next.scrollIntoView({ block: "center" });
      next.click();
      return true;
    })()
  '
  scrapeless-scraping-browser --session-id $SESSION wait 1500
  scrapeless-scraping-browser --session-id $SESSION wait "#reviews, [data-component*='Review' i]"
done

PRODUCT_ID="326716329"
SLUG="NextWall-31-35-sq-ft-Off-White-Faux-Shiplap-Vinyl-Paintable-Peel-and-Stick-Wallpaper-Roll-PP10000"

for page in $(seq 1 10); do

SID=$(scrapeless-scraping-browser new-session \
    --name "hd-reviews-p$page" --ttl 300 --proxy-country US --json \
    | jq -r '.data.taskId')

  URL="https://www.homedepot.com/p/reviews/$SLUG/$PRODUCT_ID/$page"
  scrapeless-scraping-browser --session-id $SID open "$URL"
  scrapeless-scraping-browser --session-id $SID wait 1500
  scrapeless-scraping-browser --session-id $SID wait "#reviews, [data-component*='Review' i]"
  scrapeless-scraping-browser --session-id $SID eval '/* review-extraction body */' \
    > "reviews-page-$page.json"
  scrapeless-scraping-browser stop $SID
done

// O esquema reflete exatamente o que o eval do Passo 6 emite.
// Os valores dos campos são amostras ilustrativas, não um instantâneo congelado de nenhum produto hoje.
{
  "productId": "326716329",
  "productUrl": "https://www.homedepot.com/p/reviews/<slug>/326716329/1",
  "reviewsReturned": 1,
  "reviews": [
    {
      "id": "abc123",
      "title": "Instalação fácil e qualidade sólida",
      "text": "O produto instalou-se de forma limpa e funcionou como esperado.",
      "rating": 5,
      "isRecommended": true,
      "badges": ["Comprador Verificado"],
      "reviewer": { "name": "ClienteHomeDepot" },
      "time": "2024-04-04",
      "original_source": { "name": "homedepot.com" },
      "images": [],
      "total_positive_feedback": 8,
      "total_negative_feedback": 0,
      "verified": true
    }
  ]
}

- **Interstitials do WAF.** Algumas alocações vão para a página de `Acesso Negado` da Home Depot (`bodyLen` ≪ 1000, sem marcadores de revisão). O script no Passo 6 deve detectar essa página (por exemplo, `if (/Access Denied|Error Page/i.test(document.title)) throw`) e o chamador deve tentar novamente com uma sessão nova.

## Reivindique seu plano gratuito e comece a raspar:
Junte-se à vibrante comunidade do Scrapeless para reivindicar um **plano gratuito** de $5-10 e conectar-se com outros inovadores:

[Comunidade Oficial do Scrapeless no Discord](https://discord.gg/stFPK2xKHY)
[Comunidade Oficial do Scrapeless no Telegram](https://t.me/+uELlyZh2JGw1M2Ux)

---

## FAQ

**Q1: Preciso de um proxy para raspar a Home Depot?**
Sim — 100%. A Home Depot é um site de varejo dos EUA e exibe uma página de erro genérica em egressos não dos EUA. `--proxy-country US` é obrigatório em cada sessão.

**Q2: Onde ficam as opções de preço e disponibilidade — JSON-LD ou DOM renderizado?**
Ambos. O JSON-LD envia o `offers.price`, `offers.priceCurrency` e `offers.availability` canônicos (Passo 2). Sobrescritas de preço em promoção, texto de promoção atual, o selo de disponibilidade por loja, e os botões de conclusão (Enviar para Casa / Retirada / Entrega) são preenchidos após o React hidratar e são extraídos do DOM renderizado (Passo 3).

**Q3: Como eu raspo o estoque por loja?**
Acione o modal do seletor de localização: abra o PDP, clique em "Trocar Loja", preencha o CEP, confirme. Chamadas de avaliação subsequentes na mesma sessão retornarão a visão regional. Veja o Passo 5 para o resumo completo → clique → choreografia de preenchimento. O fallback de configuração de cookie (`THD_LOCSTORE` / `THD_PERSIST`) é documentado ao final do Passo 5 para ambientes onde o modal não é acessível.

**Q4: Por que minha sessão às vezes retorna `ERR_TUNNEL_CONNECTION_FAILED`?**
O pool de proxies não tinha IP residencial disponível no momento da alocação. Crie uma nova sessão e tente novamente em breve.

**Q5: Por que a página às vezes retorna `Acesso Negado`?**
O WAF da Home Depot ocasionalmente desafia uma nova alocação. Crie uma nova sessão e tente novamente. O extractor do Passo 6 deve detectar o título da página de erro e lançar uma exceção para que o chamador possa tentar novamente com uma nova sessão.

**Q6: Como as páginas de busca e categoria paginam?**
Através do deslocamento da URL `Nao` (`?Nao=24`, `?Nao=48`, …) com 24 cartões por página. O Passo 4 cobre o extrator de listagem e o loop de paginação. Páginas de entrada de categoria (`/b/<slug>`) aceitam o mesmo deslocamento.

**Q7: Posso raspar apenas avaliações com fotos?**
Sim. Primeiro, experimente o filtro de avaliação com foto visível (Passo 7). Se esse controle estiver ausente para um determinado produto, extraia todas as avaliações visíveis e filtre posteriormente com `images.length > 0`.

**Q8: Como consigo as avaliações mais novas ou as de menor classificação?**
Use os controles de classificação da UI dentro da mesma sessão persistente — a choreografia de captura no Passo 7. Clique no controle relevante, aguarde a região de avaliação ser re-renderizada, e então execute novamente a extração `eval`.

**Q09: O que acontece quando a Home Depot muda o DOM?**
Execute novamente a passagem de descoberta: `get html "<region>"`, identifique os ancoradouros estáveis atuais (`data-testid`, `aria-label`, `[itemprop]`, ids semânticos) e ajuste os seletores `eval`. Não use nomes de classe hash como seletores permanentes.

**Q10: Quantos produtos posso coletar em uma sessão?**
Para confiabilidade, mantenha uma sessão do Scrapeless para uma raspagem lógica pequena (alguns PDPs ou algumas páginas de busca). Para trabalhos maiores, crie novas sessões por tarefa e mantenha a concorrência ≤ 3 por host (nota sobre trabalhadores paralelos no Passo 8). Distribua entre hosts para maior fan-out.

**Q11: Isso pode ser executado sem um agente de IA?**
Sim. Os comandos da CLI nos Passos 1–8 funcionam de ponta a ponta como bash. O fluxo de trabalho controlado pelo agente (habilidade + prompts em linguagem natural) é o caminho recomendado porque a habilidade transporta o padrão de descoberta → extração, as pegadinhas da espera e as regras de trabalhadores paralelos para que o prompt permaneça em uma linha.

**Q12: Por que usar uma URL canônica `/p/<slug>/<productId>` em vez de um ID de produto vazio?**
URLs somente com ID vazio como `/p/<productId>` retornaram a página de erro genérica da Home Depot na verificação. A URL canônica do PDP `/p/<slug>/<productId>` e a URL canônica de avaliações `/p/reviews/<slug>/<productId>/<page>` são os alvos confiáveis do navegador; resolva os IDs dos produtos para essas formas antes de abrir a página.