> ## Documentation Index
> Fetch the complete documentation index at: https://student-213fb9fc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Modo Avançado

> Use proxies aprimorados para scraping confiável em sites complexos, mantendo a privacidade

Firecrawl oferece diferentes tipos de proxy para ajudar você a fazer scraping de sites com diferentes níveis de complexidade. O tipo de proxy pode ser especificado usando o parâmetro `proxy`.

<div id="proxy-types">
  ### Tipos de Proxy
</div>

Firecrawl oferece suporte a três tipos de proxy:

* **basic**: Proxies básicos para fazer scraping na maioria dos sites. Rápidos e geralmente funcionam bem.
* **enhanced**: Proxies avançados para fazer scraping em sites complexos mantendo a privacidade. Mais lentos, mas mais confiáveis em determinados sites.
* **auto**: Firecrawl tentará automaticamente repetir o scraping com proxies enhanced se o proxy basic falhar. Se a nova tentativa com enhanced for bem-sucedida, 5 créditos serão cobrados pelo scraping. Se a primeira tentativa com basic for bem-sucedida, apenas o custo normal será cobrado.

Se você não especificar um proxy, o Firecrawl usará auto por padrão.

<div id="using-enhanced-mode">
  ### Usando o Modo Avançado
</div>

Ao fazer scraping de sites complexos, você pode usar o modo avançado (`enhanced mode`) para aumentar sua taxa de sucesso, mantendo a privacidade.

<CodeGroup>
  ```python Python theme={null}
  from firecrawl import Firecrawl

  firecrawl = Firecrawl(api_key='fc-YOUR-API-KEY')

  # Escolha a estratégia de proxy: 'basic' | 'enhanced' | 'auto'
  doc = firecrawl.scrape('https://example.com', formats=['markdown'], proxy='auto')

  print(doc.warning or 'ok')
  ```

  ```js Node theme={null}
  import Firecrawl from '@mendable/firecrawl-js';

  const firecrawl = new Firecrawl({ apiKey: "fc-YOUR-API-KEY" });

  // Escolha a estratégia de proxy: 'basic' | 'enhanced' | 'auto'
  const doc = await firecrawl.scrape('https://example.com', {
    formats: ['markdown'],
    proxy: 'auto'
  });

  console.log(doc.warning || 'ok');
  ```

  ```bash cURL theme={null}

  // Selecione a estratégia de proxy: 'basic' | 'enhanced' | 'auto'
  curl -X POST https://api.firecrawl.dev/v2/scrape \
      -H 'Content-Type: application/json' \
      -H 'Authorization: Bearer fc-YOUR-API-KEY' \
      -d '{
        "url": "https://example.com",
        "proxy": "auto"
      }'

  ```
</CodeGroup>

**Observação:** As requisições com proxy avançado custam 5 créditos por requisição.

<div id="using-enhanced-as-a-retry-mechanism">
  ## Usando Enhanced como mecanismo de nova tentativa
</div>

Um padrão comum é primeiro tentar fazer o scraping com as configurações de proxy padrão e, em seguida, tentar novamente no modo enhanced se você encontrar códigos de status de erro específicos (401, 403 ou 500) no campo `metadata.statusCode` da resposta. Esses códigos de status podem indicar que o site está bloqueando sua requisição.

<CodeGroup>
  ```python Python theme={null}
  # pip install firecrawl-py

  from firecrawl import Firecrawl

  firecrawl = Firecrawl(api_key="YOUR_API_KEY")

  # First try with basic proxy
  try:
      content = firecrawl.scrape("https://example.com")
      
      # Check if we got an error status code
      status_code = content.get("metadata", {}).get("statusCode")
      if status_code in [401, 403, 500]:
          print(f"Recebemos o código de status {status_code}, tentando novamente com o proxy enhanced")
          # Retry with enhanced proxy
          content = firecrawl.scrape("https://example.com", proxy="enhanced")
      
      print(content["markdown"])
  except Exception as e:
      print(f"Error: {e}")
      # Retry with enhanced proxy on exception
      try:
          content = firecrawl.scrape("https://example.com", proxy="enhanced")
          print(content["markdown"])
      except Exception as e:
          print(f"Enhanced proxy also failed: {e}")
  ```

  ```js Node theme={null}
  // npm install @mendable/firecrawl-js

  import { Firecrawl } from '@mendable/firecrawl-js';

  const firecrawl = new Firecrawl({ apiKey: 'YOUR_API_KEY' });

  // Function to scrape with retry logic
  async function scrapeWithRetry(url) {
    try {
      // First try with default proxy
      const content = await firecrawl.scrape(url);
      
      // Check if we got an error status code
      const statusCode = content?.metadata?.statusCode;
      if ([401, 403, 500].includes(statusCode)) {
        console.log(`Recebemos o código de status ${statusCode}, tentando novamente com o proxy enhanced`);
        // Retry with enhanced proxy
        return await firecrawl.scrape(url, {
          proxy: 'enhanced'
        });
      }
      
      return content;
    } catch (error) {
      console.error(`Error: ${error.message}`);
      // Retry with enhanced proxy on exception
      try {
        return await firecrawl.scrape(url, {
          proxy: 'enhanced'
        });
      } catch (retryError) {
        console.error(`Enhanced proxy also failed: ${retryError.message}`);
        throw retryError;
      }
    }
  }

  // Usage
  const content = await scrapeWithRetry('https://example.com');
  console.log(content.markdown);
  ```

  ```bash cURL theme={null}
  # First try with default proxy
  RESPONSE=$(curl -s -X POST https://api.firecrawl.dev/v2/scrape \
      -H 'Content-Type: application/json' \
      -H 'Authorization: Bearer YOUR_API_KEY' \
      -d '{
        "url": "https://example.com"
      }')

  # Extract status code from response
  STATUS_CODE=$(echo $RESPONSE | jq -r '.data.metadata.statusCode')

  # Check if status code indicates we should retry with enhanced
  if [[ "$STATUS_CODE" == "401" || "$STATUS_CODE" == "403" || "$STATUS_CODE" == "500" ]]; then
      echo "Código de status $STATUS_CODE recebido; tentando novamente com proxy enhanced"
      
      # Retry with enhanced proxy
      curl -X POST https://api.firecrawl.dev/v2/scrape \
          -H 'Content-Type: application/json' \
          -H 'Authorization: Bearer YOUR_API_KEY' \
          -d '{
            "url": "https://example.com",
            "proxy": "enhanced"
          }'
  else
      # Output the original response
      echo $RESPONSE
  fi
  ```
</CodeGroup>

Essa abordagem permite otimizar o uso de créditos, usando o modo enhanced apenas quando necessário.