> ## Documentation Index
> Fetch the complete documentation index at: https://docs.olostep.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Esegui il crawl e estrai contenuti dalle pagine del blog di Stripe

> Scopri come eseguire il crawl e estrarre contenuti dai post del blog di Stripe.

## Panoramica

Questa guida ti mostrerà come:

* Iniziare un crawl specificamente mirato ai post del blog di Stripe
* Monitorare l'avanzamento del crawl
* Recuperare e elaborare il contenuto estratto

## Eseguire il Crawl delle Pagine del Blog di Stripe

Per eseguire il crawl delle pagine del blog di Stripe, utilizza l'endpoint dei crawl con il pattern matching per mirare a URL specifici del blog. Questo recupererà il contenuto HTML completo di ciascuna pagina, che potrai poi elaborare per estrarre le informazioni di cui hai bisogno.

<CodeGroup>
  ```python crawl_stripe_blog.py theme={null}
  import requests
  import time
  import json
  from datetime import datetime

  # Configurazione
  API_URL = 'https://api.olostep.com/v1'
  API_KEY = '<your_olostep_api_key>'
  HEADERS = {
      'Content-Type': 'application/json',
      'Authorization': f'Bearer {API_KEY}'
  }

  # Registra l'ora di inizio per il monitoraggio della durata del crawl
  crawl_start_time = time.time()

  print(f"[{datetime.now().strftime('%H:%M:%S')}] Inizio del crawl del blog di Stripe...")

  # Inizia un crawl focalizzato sui post del blog di ingegneria di Stripe
  # Puoi adattare i pattern in base ai tuoi interessi specifici
  payload = {
      "start_url": "https://stripe.com/blog",
      "include_urls": ["/blog/engineering/**"],  # Focalizzati sui post di ingegneria
      "max_pages": 25  # Limita a 25 pagine per questo esempio
  }

  # Avvia il crawl
  print("Inizio del crawl dei post del blog di ingegneria di Stripe...")
  response = requests.post(f'{API_URL}/crawls', headers=HEADERS, json=payload)
  data = response.json()
  crawl_id = data['id']
  print(f"Crawl avviato con ID: {crawl_id}")

  # Monitora l'avanzamento del crawl
  while True:
      status_response = requests.get(f'{API_URL}/crawls/{crawl_id}', headers=HEADERS)
      status_data = status_response.json()
      print(f"Stato del crawl: {status_data['status']} - Pagine scansionate: {status_data.get('pages_count', 0)}")
      
      if status_data['status'] == 'completed' or status_data['status'] == 'failed':
          break
          
      # Attendi 5 secondi prima di controllare di nuovo
      time.sleep(5)

  # Calcola e visualizza la durata del crawl
  crawl_duration = time.time() - crawl_start_time
  print(f"[{datetime.now().strftime('%H:%M:%S')}] Crawl completato in {crawl_duration:.2f} secondi")
  ```
</CodeGroup>

## Convertire il Contenuto del Blog in Markdown

Un modo potente per utilizzare il contenuto estratto è convertirlo in formato markdown, ideale per alimentare LLM o creare una base di conoscenza. Ecco come recuperare e convertire il contenuto del blog in markdown:

<CodeGroup>
  ```python blog_to_markdown.py theme={null}
  import requests
  import time
  import json
  from datetime import datetime
  import os
  from concurrent.futures import ThreadPoolExecutor, as_completed

  # Configurazione
  API_URL = 'https://api.olostep.com/v1'
  API_KEY = '<your_olostep_api_key>'
  HEADERS = {
      'Content-Type': 'application/json',
      'Authorization': f'Bearer {API_KEY}'
  }

  # Funzione per recuperare il contenuto in formato markdown
  def retrieve_content(retrieve_id, formats):
      params = {
          "retrieve_id": retrieve_id,
          "formats": json.dumps(formats)
      }
      response = requests.get(f"{API_URL}/retrieve", headers=HEADERS, params=params)
      return response.json()

  # Continuando dall'esempio di crawl precedente
  if status_data['status'] == 'completed':
      print(f"\nCrawl completato! Recuperate {status_data['pages_count']} pagine.")
      pages_response = requests.get(f'{API_URL}/crawls/{crawl_id}/pages', headers=HEADERS)
      pages_data = pages_response.json()
      
      # Crea la directory di output se non esiste
      os.makedirs("output", exist_ok=True)
      
      # Prepara a raccogliere il contenuto markdown
      markdown_pages = []
      total_pages = len(pages_data['pages'])
      
      # Elabora le pagine in parallelo per ottenere il contenuto markdown
      with ThreadPoolExecutor(max_workers=10) as executor:
          # Crea future per il recupero del contenuto
          future_to_page = {
              executor.submit(retrieve_content, page['retrieve_id'], ["markdown"]): page
              for page in pages_data['pages']
          }
          
          # Elabora i risultati man mano che vengono completati
          for i, future in enumerate(as_completed(future_to_page), 1):
              page = future_to_page[future]
              url = page['url']
              print(f"Elaborazione {i}/{total_pages}: {url}")
              
              try:
                  content_data = future.result()
                  if content_data and "markdown_content" in content_data:
                      markdown_pages.append({
                          'url': url,
                          'title': page['title'],
                          'markdown_content': content_data['markdown_content']
                      })
                      print(f"✓ Contenuto markdown recuperato per {url}")
                  else:
                      print(f"⚠ Nessun contenuto markdown per {url}")
              except Exception as e:
                  print(f"❌ Errore nel recupero del contenuto per {url}: {str(e)}")
      
      # Salva tutto il contenuto markdown in un unico file
      output_file = "output/stripe_blog_markdown.md"
      
      with open(output_file, "w", encoding="utf-8") as f:
          for page in markdown_pages:
              # Scrivi l'intestazione della pagina con titolo e URL
              f.write(f"URL: {page['url']}\n\n")
              
              # Scrivi il contenuto markdown
              f.write(f"{page['markdown_content']}\n\n")
              
              # Aggiungi un separatore tra le pagine
              f.write("---\n\n")
              
              print(f"✓ Aggiunto contenuto markdown da {page['url']}")

      print(f"\n✅ Processo completato! Tutto il contenuto markdown è stato salvato in '{output_file}'")
      print(f"Totale pagine elaborate: {len(markdown_pages)}")
  else:
      print(f"Crawl fallito con stato: {status_data['status']}")
  ```
</CodeGroup>

### Esempio di Output Markdown

Il file markdown risultante conterrà tutto il contenuto del blog estratto in un formato pulito e strutturato:

```markdown theme={null}
URL: https://stripe.com/blog/using-ml-to-detect-and-respond-to-performance-degradations

## Usare ML per rilevare e rispondere ai degradi delle prestazioni

Di Jane Smith, Senior Engineer presso Stripe

In Stripe, elaboriamo milioni di richieste API ogni giorno...

---

URL: https://stripe.com/blog/building-robust-payment-systems

## Costruire un sistema di pagamento robusto

Di John Doe, Engineering Manager

L'affidabilità è al centro dell'infrastruttura di Stripe...

---
```

## Prossimi Passi

Ora che hai eseguito con successo il crawl e estratto contenuti dal blog di Stripe, puoi:

1. **Espandere il tuo crawl**: Modifica il parametro `include_urls` per eseguire il crawl di altre sezioni del blog di Stripe
2. **Implementare aggiornamenti regolari**: Imposta un lavoro pianificato per eseguire periodicamente il crawl per nuovi contenuti
3. **Eseguire un'analisi più approfondita**: Usa strumenti NLP per estrarre approfondimenti dal contenuto del blog
4. **Costruire un motore di ricerca**: Crea un database ricercabile del contenuto del blog di Stripe
5. **Alimentare LLM**: Usa il contenuto markdown come contesto per LLM per rispondere a domande sulle pratiche ingegneristiche di Stripe

Utilizzando le capacità di crawl dei contenuti di Olostep, puoi costruire strumenti potenti per monitorare e analizzare la strategia dei contenuti di qualsiasi sito web.