문서

문서

ActiCrawl을 사용하여 웹 스크래핑 워크플로를 자동화하는 방법을 알아보세요

소개 빠른 시작 플레이그라운드 설치 아키텍처 웹 크롤링 데이터 추출 API 엔드포인트 인증 예제

API 예제

이 가이드는 ActiCrawl API의 일반적인 사용 사례에 대한 실용적인 예제를 제공합니다. 각 예제에는 여러 프로그래밍 언어의 완전한 코드 스니펫이 포함되어 있습니다.

기본 웹 스크래핑

기사 콘텐츠 추출

블로그 게시물이나 뉴스 기사를 스크래핑하고 깔끔하고 읽기 쉬운 콘텐츠를 얻습니다:

python 
import requests

api_key = 'YOUR_API_KEY'

response = requests.post(
    'https://api.acticrawl.com/v1/scrape',
    headers={'X-API-Key': api_key},
    json={
        'url': 'https://techcrunch.com/2024/01/15/openai-gpt-5/',
        'formats': ['markdown'],
        'options': {
            'onlyMainContent': True
        }
    }
)

article = response.json()
print(article['data']['markdown'])

스크린샷 생성

모든 웹페이지의 스크린샷 캡처:

javascript 
const axios = require('axios');

async function captureScreenshot(url) {
  const response = await axios.post('https://api.acticrawl.com/v1/scrape', {
    url: url,
    formats: ['screenshot'],
    options: {
      waitFor: 3000  // 페이지 로드를 위해 3초 대기
    }
  }, {
    headers: { 'X-API-Key': 'YOUR_API_KEY' }
  });

  // 스크린샷을 파일로 저장
  const fs = require('fs');
  const buffer = Buffer.from(response.data.data.screenshot, 'base64');
  fs.writeFileSync('screenshot.png', buffer);
}

captureScreenshot('https://stripe.com');

전자상거래 데이터 추출

제품 정보 스크래핑

전자상거래 사이트에서 구조화된 제품 데이터 추출:

python 
import requests
import json

def scrape_product(product_url):
    response = requests.post(
        'https://api.acticrawl.com/v1/scrape',
        headers={'X-API-Key': 'YOUR_API_KEY'},
        json={
            'url': product_url,
            'formats': ['json', 'screenshot'],
            'options': {
                'waitFor': 5000,  # 동적 콘텐츠 대기
                'onlyIncludeTags': [
                    'h1',  # 제품 제목
                    '.price',  # 가격
                    '.description',  # 설명
                    '.product-image',  # 이미지
                    '.reviews'  # 리뷰
                ]
            }
        }
    )

    return response.json()

# 사용 예시
product = scrape_product('https://amazon.com/dp/B08N5WRWNW')
print(f"제목: {product['data']['metadata']['title']}")
print(f"가격: {product['data']['json']['price']}")

가격 변동 모니터링

시간에 따른 제품 가격 추적:

javascript 
const cron = require('node-cron');
const axios = require('axios');
const fs = require('fs');

async function checkPrice(url) {
  const response = await axios.post('https://api.acticrawl.com/v1/scrape', {
    url: url,
    formats: ['json'],
    options: {
      onlyIncludeTags: ['.price', '.product-title']
    }
  }, {
    headers: { 'X-API-Key': 'YOUR_API_KEY' }
  });

  const data = response.data.data;
  const price = data.json.price;
  const timestamp = new Date().toISOString();

  // CSV에 가격 기록
  fs.appendFileSync('prices.csv', `${timestamp},${price}\n`);

  return price;
}

// 매시간 가격 확인
cron.schedule('0 * * * *', () => {
  checkPrice('https://example.com/product');
});

뉴스 및 콘텐츠 수집

여러 뉴스 기사 스크래핑

뉴스 웹사이트에서 기사 수집:

python 
import requests
from datetime import datetime

def scrape_news_site(base_url, max_articles=10):
    # 먼저 홈페이지를 가져와서 기사 링크 찾기
    response = requests.post(
        'https://api.acticrawl.com/v1/crawl',
        headers={'X-API-Key': 'YOUR_API_KEY'},
        json={
            'url': base_url,
            'match': f'{base_url}/article/**',
            'selector': 'article a[href]',
            'limit': max_articles,
            'depth': 1,
            'formats': ['markdown'],
            'options': {
                'onlyMainContent': True
            }
        }
    )

    articles = response.json()['data']

    # 기사 처리
    for article in articles:
        print(f"제목: {article['metadata']['title']}")
        print(f"URL: {article['url']}")
        print(f"게시일: {article['metadata']['publishedTime']}")
        print(f"내용: {article['markdown'][:200]}...")
        print("-" * 80)

    return articles

# 사용 예시
news = scrape_news_site('https://news.ycombinator.com', max_articles=5)

모든 웹사이트를 RSS 피드로 변환

모든 웹사이트를 RSS 피드로 변환:

javascript 
const axios = require('axios');
const RSS = require('rss');

async function websiteToRSS(siteUrl) {
  // 최근 게시물을 위해 웹사이트 크롤링
  const response = await axios.post('https://api.acticrawl.com/v1/crawl', {
    url: siteUrl,
    match: `${siteUrl}/blog/**`,
    limit: 20,
    depth: 1,
    formats: ['markdown'],
    options: {
      onlyMainContent: true
    }
  }, {
    headers: { 'X-API-Key': 'YOUR_API_KEY' }
  });

  // RSS 피드 생성
  const feed = new RSS({
    title: `${siteUrl} RSS 피드`,
    description: `${siteUrl}의 최신 게시물`,
    feed_url: `${siteUrl}/rss`,
    site_url: siteUrl,
  });

  // 피드에 항목 추가
  response.data.data.forEach(article => {
    feed.item({
      title: article.metadata.title,
      description: article.markdown.substring(0, 300) + '...',
      url: article.url,
      date: article.metadata.publishedTime || new Date()
    });
  });

  return feed.xml();
}

연구 및 데이터 수집

학술 논문 수집

연구 논문과 메타데이터 수집:

python 
import requests
import pandas as pd

def collect_research_papers(search_url, query):
    response = requests.post(
        'https://api.acticrawl.com/v1/search',
        headers={'X-API-Key': 'YOUR_API_KEY'},
        json={
            'url': search_url,
            'query': query,
            'limit': 50,
            'depth': 2
        }
    )

    papers = response.json()['data']['results']

    # 분석을 위해 DataFrame으로 변환
    df = pd.DataFrame([{
        'title': p['title'],
        'url': p['url'],
        'excerpt': p['excerpt'],
        'relevance': p['relevance_score']
    } for p in papers])

    # CSV로 저장
    df.to_csv(f'research_{query}.csv', index=False)

    return df

# 사용 예시
papers = collect_research_papers(
    'https://arxiv.org',
    'machine learning transformers'
)

웹사이트 변경 감지

웹사이트 변경 사항 모니터링:

javascript 
const axios = require('axios');
const crypto = require('crypto');
const nodemailer = require('nodemailer');

async function checkForChanges(url, selector) {
  // 현재 콘텐츠 스크래핑
  const response = await axios.post('https://api.acticrawl.com/v1/scrape', {
    url: url,
    formats: ['html'],
    options: {
      onlyIncludeTags: [selector]
    }
  }, {
    headers: { 'X-API-Key': 'YOUR_API_KEY' }
  });

  const content = response.data.data.html;
  const hash = crypto.createHash('md5').update(content).digest('hex');

  // 저장된 해시와 비교
  const fs = require('fs');
  const hashFile = 'content-hashes.json';
  let hashes = {};

  if (fs.existsSync(hashFile)) {
    hashes = JSON.parse(fs.readFileSync(hashFile));
  }

  if (hashes[url] && hashes[url] !== hash) {
    // 콘텐츠가 변경됨!
    await sendNotification(url, content);
  }

  // 해시 업데이트
  hashes[url] = hash;
  fs.writeFileSync(hashFile, JSON.stringify(hashes));
}

async function sendNotification(url, newContent) {
  // 이메일 알림 전송
  const transporter = nodemailer.createTransport({
    // 이메일 서비스 구성
  });

  await transporter.sendMail({
    to: 'your-email@example.com',
    subject: `웹사이트 변경됨: ${url}`,
    html: `웹사이트가 업데이트되었습니다:<br><br>${newContent}`
  });
}

SEO 및 마케팅

경쟁사 분석

경쟁사 웹사이트 분석:

python 
import requests
from collections import Counter

def analyze_competitor(competitor_url):
    # 사이트 구조 가져오기
    map_response = requests.post(
        'https://api.acticrawl.com/v1/map',
        headers={'X-API-Key': 'YOUR_API_KEY'},
        json={
            'url': competitor_url,
            'limit': 100,
            'depth': 3
        }
    )

    site_structure = map_response.json()['data']

    # 페이지 샘플 분석
    sample_urls = site_structure['urls'][:10]
    keywords = []

    for url in sample_urls:
        page_response = requests.post(
            'https://api.acticrawl.com/v1/scrape',
            headers={'X-API-Key': 'YOUR_API_KEY'},
            json={
                'url': url,
                'formats': ['json'],
                'options': {
                    'onlyMainContent': True
                }
            }
        )

        metadata = page_response.json()['data']['metadata']
        if metadata.get('keywords'):
            keywords.extend(metadata['keywords'])

    # 키워드 분석
    keyword_freq = Counter(keywords)

    return {
        'total_pages': len(site_structure['urls']),
        'site_structure': site_structure['structure'],
        'top_keywords': keyword_freq.most_common(20)
    }

# 사용 예시
analysis = analyze_competitor('https://competitor.com')
print(f"전체 페이지 수: {analysis['total_pages']}")
print(f"상위 키워드: {analysis['top_keywords']}")

콘텐츠 아이디어 생성

업계의 트렌드 토픽 찾기:

javascript 
async function findTrendingTopics(industrySites) {
  const allArticles = [];

  // 여러 사이트에서 최근 기사 스크래핑
  for (const site of industrySites) {
    const response = await axios.post('https://api.acticrawl.com/v1/crawl', {
      url: site,
      match: `${site}/**`,
      selector: 'article a, .post a',
      limit: 20,
      depth: 1,
      formats: ['markdown'],
      options: {
        onlyMainContent: true
      }
    }, {
      headers: { 'X-API-Key': 'YOUR_API_KEY' }
    });

    allArticles.push(...response.data.data);
  }

  // 주제와 키워드 추출
  const topics = {};

  allArticles.forEach(article => {
    const keywords = article.metadata.keywords || [];
    keywords.forEach(keyword => {
      topics[keyword] = (topics[keyword] || 0) + 1;
    });
  });

  // 빈도순 정렬
  const trending = Object.entries(topics)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 10);

  return trending;
}

// 사용 예시
const sites = [
  'https://techcrunch.com',
  'https://theverge.com',
  'https://wired.com'
];

findTrendingTopics(sites).then(trends => {
  console.log('트렌드 토픽:');
  trends.forEach(([topic, count]) => {
    console.log(`- ${topic}: ${count}번 언급됨`);
  });
});

오류 처리 및 모범 사례

강력한 오류 처리

항상 적절한 오류 처리를 구현하세요:

python 
import requests
import time
from requests.exceptions import RequestException

def scrape_with_retry(url, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                'https://api.acticrawl.com/v1/scrape',
                headers={'X-API-Key': 'YOUR_API_KEY'},
                json={'url': url, 'formats': ['markdown']},
                timeout=30
            )

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:
                # 속도 제한 - 대기 후 재시도
                retry_after = int(response.headers.get('Retry-After', 60))
                print(f"속도 제한됨. {retry_after}초 대기 중...")
                time.sleep(retry_after)
            else:
                print(f"오류 {response.status_code}: {response.text}")

        except RequestException as e:
            print(f"요청 실패: {e}")

        if attempt < max_retries - 1:
            time.sleep(2 ** attempt)  # 지수 백오프

    return None

배치 처리

여러 URL을 효율적으로 처리:

javascript 
async function batchScrape(urls, batchSize = 5) {
  const results = [];

  // URL을 배치로 처리
  for (let i = 0; i < urls.length; i += batchSize) {
    const batch = urls.slice(i, i + batchSize);

    const promises = batch.map(url => 
      axios.post('https://api.acticrawl.com/v1/scrape', {
        url: url,
        formats: ['markdown', 'metadata']
      }, {
        headers: { 'X-API-Key': 'YOUR_API_KEY' }
      }).catch(err => ({ error: err.message, url }))
    );

    const batchResults = await Promise.all(promises);
    results.push(...batchResults);

    // 속도 제한 준수
    if (i + batchSize < urls.length) {
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }

  return results;
}

다음 단계

이 예제들은 ActiCrawl API로 가능한 많은 것들 중 일부만을 보여줍니다. 더 고급 사용 사례를 위해:

  1. 완전한 엔드포인트 문서를 위해 API 참조를 탐색하세요
  2. 프로그래밍 언어용 SDK 및 라이브러리를 확인하세요
  3. 지원 및 토론을 위해 개발자 커뮤니티에 참여하세요
  4. 맞춤형 솔루션을 위해 엔터프라이즈 영업 팀에 문의하세요

즐거운 스크래핑 되세요! 🚀