Tutorial ScrapeGraphAI: Web Scraping Cerdas dengan LLM dan Graph Logic
Pendahuluan
Web scraping adalah salah satu teknik paling penting dalam dunia data engineering dan data science. Namun, scraping tradisional memiliki banyak keterbatasan: script yang mudah rusak ketika struktur HTML berubah, kesulitan mengekstrak data dari halaman dinamis, dan kebutuhan untuk menulis parser yang spesifik untuk setiap website.
ScrapeGraphAI hadir sebagai solusi modern yang menggabungkan kekuatan Large Language Models (LLM) dengan graph-based pipeline untuk web scraping. Dengan ScrapeGraphAI, Anda cukup mendeskripsikan data apa yang ingin diekstrak dalam bahasa natural, dan library ini akan secara otomatis menavigasi halaman web, memahami strukturnya, dan mengekstrak informasi yang diminta.
Library ini mendukung berbagai provider LLM termasuk OpenAI, Anthropic Claude, Google Gemini, Ollama untuk model lokal, dan banyak lagi. ScrapeGraphAI juga menyediakan beberapa jenis graph pipeline yang bisa disesuaikan dengan kebutuhan scraping Anda.
Dalam tutorial ini, kita akan mempelajari cara menginstal, mengonfigurasi, dan menggunakan ScrapeGraphAI untuk berbagai skenario scraping mulai dari yang sederhana hingga yang kompleks.
Instalasi
Prasyarat
Pastikan Anda sudah memiliki Python 3.9 atau lebih baru terinstal di sistem Anda. ScrapeGraphAI juga membutuhkan beberapa dependensi sistem.
Instalasi Dasar
pip install scrapegraphai
Instalasi dengan Dukungan Browser (untuk halaman dinamis)
pip install scrapegraphai[browsers]
playwright install chromium
Instalasi dengan Dukungan Model Lokal
Jika Anda ingin menggunakan model lokal melalui Ollama:
pip install scrapegraphai[local]
Pastikan Ollama sudah terinstal dan model yang diinginkan sudah di-download:
ollama pull llama3.1
ollama pull nomic-embed-text
Instalasi Lengkap
Untuk menginstal semua dependensi opsional:
pip install scrapegraphai[all]
Verifikasi Instalasi
import scrapegraphai
print(scrapegraphai.version)
Konsep Dasar
Arsitektur Graph Pipeline
ScrapeGraphAI bekerja dengan konsep graph pipeline. Setiap operasi scraping direpresentasikan sebagai sebuah graph yang terdiri dari beberapa node:
Jenis-Jenis Graph
ScrapeGraphAI menyediakan beberapa graph bawaan:
- SmartScraperGraph: Scraping satu halaman dengan prompt natural language
- SearchGraph: Mencari di web terlebih dahulu, lalu scraping hasilnya
- SpeechGraph: Scraping dan konversi hasil ke audio
- ScriptCreatorGraph: Generate script scraping Python dari prompt
- SmartScraperMultiGraph: Scraping beberapa URL sekaligus
Basic Usage
Konfigurasi dengan OpenAI
from scrapegraphai.graphs import SmartScraperGraph
graphconfig = {
"llm": {
"apikey": "sk-your-openai-api-key",
"model": "openai/gpt-4o-mini",
},
"verbose": True,
"headless": True,
}
smartscraper = SmartScraperGraph(
prompt="Ekstrak semua judul artikel dan deskripsinya",
source="https://example.com/blog",
config=graphconfig,
)
result = smartscraper.run()
print(result)
Konfigurasi dengan Anthropic Claude
from scrapegraphai.graphs import SmartScraperGraph
graphconfig = {
"llm": {
"apikey": "sk-ant-your-anthropic-key",
"model": "anthropic/claude-sonnet-4-20250514",
},
"verbose": True,
"headless": True,
}
smartscraper = SmartScraperGraph(
prompt="Ambil daftar produk beserta harga dan rating",
source="https://example.com/products",
config=graphconfig,
)
result = smartscraper.run()
print(result)
Konfigurasi dengan Model Lokal (Ollama)
from scrapegraphai.graphs import SmartScraperGraph
graphconfig = {
"llm": {
"model": "ollama/llama3.1",
"temperature": 0,
"baseurl": "http://localhost:11434",
},
"embeddings": {
"model": "ollama/nomic-embed-text",
"baseurl": "http://localhost:11434",
},
"verbose": True,
"headless": True,
}
smartscraper = SmartScraperGraph(
prompt="Ekstrak semua nama perusahaan dan alamatnya",
source="https://example.com/directory",
config=graphconfig,
)
result = smartscraper.run()
print(result)
Scraping dari Teks atau HTML Lokal
ScrapeGraphAI tidak hanya bisa scraping dari URL, tetapi juga dari teks atau file HTML lokal:
from scrapegraphai.graphs import SmartScraperGraph
htmlcontent = """
Laptop Gaming X1
Rp 15.000.000
RAM 16GB, SSD 512GB, RTX 4060
Laptop Ultrabook Y2
Rp 12.000.000
RAM 8GB, SSD 256GB, Intel Iris
"""
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
}
smartscraper = SmartScraperGraph(
prompt="Ekstrak nama laptop, harga, dan spesifikasinya dalam format JSON",
source=htmlcontent,
config=graphconfig,
)
result = smartscraper.run()
print(result)
Output yang dihasilkan:
{
"products": [
{
"name": "Laptop Gaming X1",
"price": "Rp 15.000.000",
"specs": "RAM 16GB, SSD 512GB, RTX 4060"
},
{
"name": "Laptop Ultrabook Y2",
"price": "Rp 12.000.000",
"specs": "RAM 8GB, SSD 256GB, Intel Iris"
}
]
}
Advanced Usage
Menggunakan Output Schema dengan Pydantic
Untuk mendapatkan output yang terstruktur dan konsisten, Anda bisa mendefinisikan schema menggunakan Pydantic:
from pydantic import BaseModel, Field
from typing import List
from scrapegraphai.graphs import SmartScraperGraph
class Article(BaseModel):
title: str = Field(description="Judul artikel")
author: str = Field(description="Nama penulis")
date: str = Field(description="Tanggal publikasi")
summary: str = Field(description="Ringkasan artikel")
class ArticleList(BaseModel):
articles: List[Article] = Field(description="Daftar artikel")
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"verbose": True,
}
smartscraper = SmartScraperGraph(
prompt="Ekstrak semua artikel dari halaman ini",
source="https://example.com/news",
config=graphconfig,
schema=ArticleList,
)
result = smartscraper.run()
for article in result.get("articles", []):
print(f"Judul: {article['title']}")
print(f"Penulis: {article['author']}")
print(f"Tanggal: {article['date']}")
print(f"Ringkasan: {article['summary']}")
print("---")
Multi-URL Scraping
Untuk scraping beberapa URL sekaligus:
from scrapegraphai.graphs import SmartScraperMultiGraph
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"verbose": True,
"headless": True,
}
urls = [
"https://example.com/page1",
"https://example.com/page2",
"https://example.com/page3",
]
multiscraper = SmartScraperMultiGraph(
prompt="Ekstrak judul halaman dan semua link yang ada",
source=urls,
config=graphconfig,
)
result = multiscraper.run()
print(result)
SearchGraph: Pencarian Web + Scraping
SearchGraph menggabungkan pencarian web dengan scraping. Anda memberikan query pencarian, dan ScrapeGraphAI akan mencari di web, mengambil halaman-halaman yang relevan, lalu mengekstrak informasi:
from scrapegraphai.graphs import SearchGraph
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"maxresults": 5,
"verbose": True,
}
searchscraper = SearchGraph(
prompt="Apa saja framework Python terpopuler untuk machine learning di 2026?",
config=graphconfig,
)
result = searchscraper.run()
print(result)
ScriptCreatorGraph: Generate Script Scraping
Jika Anda ingin mendapatkan script Python yang bisa dijalankan ulang tanpa LLM:
from scrapegraphai.graphs import ScriptCreatorGraph
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"verbose": True,
"library": "beautifulsoup",
}
scriptcreator = ScriptCreatorGraph(
prompt="Buat script untuk mengekstrak semua judul berita dan linknya",
source="https://example.com/news",
config=graphconfig,
)
result = scriptcreator.run()
print(result)
Output berupa script Python yang menggunakan BeautifulSoup atau library scraping tradisional lainnya.
Konfigurasi Proxy dan Rate Limiting
Untuk scraping yang lebih aman dan menghormati rate limit:
graphconfig = {
"llm": {
"api
key": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"loaderkwargs": {
"proxy": {
"server": "http://proxy-server:8080",
"username": "user",
"password": "pass",
},
},
"verbose": True,
"headless": True,
}
Menangani Halaman Dinamis dengan JavaScript
Untuk halaman yang membutuhkan JavaScript rendering:
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"headless": True,
"browsertype": "chromium",
"loaderkwargs": {
"waituntil": "networkidle",
"timeout": 30000,
},
"verbose": True,
}
smartscraper = SmartScraperGraph(
prompt="Ekstrak data dari tabel yang dimuat secara dinamis",
source="https://example.com/dynamic-table",
config=graphconfig,
)
result = smartscraper.run()
Custom Graph Pipeline
Anda bisa membuat pipeline graph kustom untuk kebutuhan scraping yang lebih kompleks:
from scrapegraphai.graphs import BaseGraph
from scrapegraphai.nodes import FetchNode, ParseNode, GenerateAnswerNode
class CustomScraperGraph(BaseGraph):
def init(self, prompt, source, config):
self.prompt = prompt
self.source = source
self.config = config
fetchnode = FetchNode(
input="url | localdir",
output=["doc"],
nodeconfig={"verbose": config.get("verbose", False)},
)
parsenode = ParseNode(
input="doc",
output=["parseddoc"],
nodeconfig={"chunksize": 4096},
)
generatenode = GenerateAnswerNode(
input="userprompt & parseddoc",
output=["answer"],
nodeconfig={
"llmmodel": config["llm"],
"verbose": config.get("verbose", False),
},
)
super().init(
nodes=[fetchnode, parsenode, generatenode],
edges=[
(fetchnode, parsenode),
(parsenode, generatenode),
],
entrypoint=fetchnode,
)
Contoh Proyek: Scraping Job Listings
Berikut contoh proyek lengkap untuk scraping lowongan kerja:
import json
from pydantic import BaseModel, Field
from typing import List, Optional
from scrapegraphai.graphs import SmartScraperGraph
class JobListing(BaseModel):
title: str = Field(description="Judul posisi")
company: str = Field(description="Nama perusahaan")
location: str = Field(description="Lokasi kerja")
salary: Optional[str] = Field(description="Range gaji jika tersedia")
requirements: List[str] = Field(description="Daftar persyaratan")
jobtype: str = Field(description="Tipe pekerjaan: remote/onsite/hybrid")
class JobListingResult(BaseModel):
jobs: List[JobListing] = Field(description="Daftar lowongan kerja")
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"verbose": True,
"headless": True,
}
scraper = SmartScraperGraph(
prompt="""
Ekstrak semua lowongan kerja dari halaman ini.
Untuk setiap lowongan, ambil judul posisi, nama perusahaan,
lokasi, range gaji (jika ada), persyaratan utama,
dan tipe pekerjaan (remote/onsite/hybrid).
""",
source="https://example.com/jobs",
config=graphconfig,
schema=JobListingResult,
)
result = scraper.run()
with open("joblistings.json", "w", encoding="utf-8") as f:
json.dump(result, f, indent=2, ensureascii=False)
print(f"Berhasil mengekstrak {len(result.get('jobs', []))} lowongan kerja")
Contoh Proyek: Monitoring Harga E-Commerce
import json
from datetime import datetime
from pydantic import BaseModel, Field
from typing import List, Optional
from scrapegraphai.graphs import SmartScraperMultiGraph
class Product(BaseModel):
name: str = Field(description="Nama produk")
price: str = Field(description="Harga produk")
originalprice: Optional[str] = Field(description="Harga asli sebelum diskon")
discount: Optional[str] = Field(description="Persentase diskon")
rating: Optional[str] = Field(description="Rating produk")
soldcount: Optional[str] = Field(description="Jumlah terjual")
class ProductList(BaseModel):
products: List[Product] = Field(description="Daftar produk")
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"verbose": True,
"headless": True,
}
categories = [
"https://example-shop.com/laptops",
"https://example-shop.com/phones",
"https://example-shop.com/tablets",
]
multiscraper = SmartScraperMultiGraph(
prompt="""
Ekstrak semua produk dari halaman ini termasuk
nama, harga saat ini, harga asli, diskon, rating,
dan jumlah terjual.
""",
source=categories,
config=graphconfig,
schema=ProductList,
)
result = multiscraper.run()
timestamp = datetime.now().isoformat()
output = {
"scrapedat": timestamp,
"data": result,
}
with open(f"prices{datetime.now().strftime('%Y%m%d')}.json", "w") as f:
json.dump(output, f, indent=2, ensureascii=False)
print(f"Data harga berhasil disimpan pada {timestamp}")
Best Practices
1. Pilih Model yang Tepat
Untuk scraping sederhana, model kecil seperti gpt-4o-mini sudah cukup dan lebih hemat biaya. Gunakan model yang lebih besar seperti gpt-4o atau claude-sonnet hanya untuk halaman yang kompleks atau ketika akurasi sangat penting.
2. Gunakan Schema Pydantic
Selalu definisikan output schema dengan Pydantic untuk mendapatkan hasil yang konsisten dan terstruktur. Ini juga membantu LLM memahami format output yang diharapkan.
3. Tulis Prompt yang Spesifik
Prompt yang terlalu umum seperti "ambil semua data" akan menghasilkan output yang tidak konsisten. Sebutkan secara spesifik data apa yang ingin diekstrak.
# Kurang baik
prompt = "Ambil semua informasi dari halaman ini"
Lebih baik
prompt = "Ekstrak nama produk, harga dalam Rupiah, dan rating bintang (1-5) dari setiap item produk"
4. Tangani Error dengan Baik
from scrapegraphai.graphs import SmartScraperGraph
try:
scraper = SmartScraperGraph(
prompt="Ekstrak data produk",
source="https://example.com/products",
config=graphconfig,
)
result = scraper.run()
if result:
print("Scraping berhasil:", result)
else:
print("Tidak ada data yang ditemukan")
except Exception as e:
print(f"Error saat scraping: {e}")
5. Hormati Rate Limit dan robots.txt
Selalu perhatikan rate limit website yang Anda scrape. Tambahkan delay antar request jika perlu, dan periksa robots.txt sebelum scraping.
6. Gunakan Model Lokal untuk Volume Tinggi
Jika Anda perlu melakukan scraping dalam volume besar, pertimbangkan untuk menggunakan model lokal melalui Ollama. Ini akan menghemat biaya API secara drastis.
7. Cache Hasil Scraping
Untuk menghindari request berulang ke website yang sama:
import json
import hashlib
import os
def scrapewithcache(prompt, url, config, cachedir="cache"):
os.makedirs(cachedir, existok=True)
cachekey = hashlib.md5(f"{prompt}{url}".encode()).hexdigest()
cachefile = os.path.join(cachedir, f"{cachekey}.json")
if os.path.exists(cachefile):
with open(cachefile, "r") as f:
return json.load(f)
scraper = SmartScraperGraph(
prompt=prompt,
source=url,
config=config,
)
result = scraper.run()
with open(cachefile, "w") as f:
json.dump(result, f, indent=2)
return result
8. Logging dan Monitoring
Aktifkan verbose mode selama development untuk memahami alur pipeline:
graphconfig = {
"llm": {
"apikey": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"verbose": True,
}
Perbandingan dengan Library Scraping Lainnya
| Fitur | ScrapeGraphAI | BeautifulSoup | Scrapy | Selenium |
|-------|--------------|---------------|--------|----------|
| Natural Language Prompt | Ya | Tidak | Tidak | Tidak |
| Tanpa Menulis Selector | Ya | Tidak | Tidak | Tidak |
| Halaman Dinamis | Ya | Tidak | Plugin | Ya |
| Structured Output | Ya (Pydantic) | Manual | Manual | Manual |
| Multi-LLM Support | Ya | N/A | N/A | N/A |
| Model Lokal | Ya (Ollama) | N/A | N/A | N/A |
| Biaya per Request | Ada (LLM) | Gratis | Gratis | Gratis |
| Kecepatan | Sedang | Cepat | Cepat | Lambat |
Troubleshooting
Error: Model Not Found
Pastikan format model menggunakan prefix provider:
# Benar
"model": "openai/gpt-4o-mini"
"model": "anthropic/claude-sonnet-4-20250514"
"model": "ollama/llama3.1"
Salah
"model": "gpt-4o-mini"
Error: Playwright Not Installed
Jika mengalami error terkait browser:
pip install playwright
playwright install chromium
Hasil Scraping Kosong
- Periksa apakah URL bisa diakses
- Coba tambahkan
headless: Truedanbrowsertype: chromiumdi config - Pastikan prompt cukup spesifik
- Periksa apakah website memblokir bot
Timeout Error
Tambahkan timeout yang lebih panjang:
graphconfig = {
"llm": {
"api
key": "sk-your-api-key",
"model": "openai/gpt-4o-mini",
},
"loader_kwargs": {
"timeout": 60000,
},
}
Kesimpulan
ScrapeGraphAI merupakan terobosan dalam dunia web scraping yang menggabungkan kemudahan natural language processing dengan kekuatan graph-based pipeline. Beberapa keunggulan utamanya:
Dengan ScrapeGraphAI, Anda bisa fokus pada data apa yang ingin didapatkan, bukan bagaimana cara mendapatkannya. Library ini sangat cocok untuk data scientist, data engineer, dan developer yang membutuhkan solusi scraping yang cepat dan adaptif.
Untuk informasi lebih lanjut, kunjungi dokumentasi resmi ScrapeGraphAI di GitHub repository mereka.