Introduction

import { Scrapeless } from '@scrapeless-ai/sdk';
const client = new Scrapeless({
  apiKey: 'YOUR_API_KEY',
});
 
async function runTask() {
  const result = await client.scraping.scrape({
    actor: 'scraper.shopee',
    input: {
      url: 'https://shopee.tw/a-i.10228173.24803858474'
    }
  });
 
  return result;
}
 
runTask()
  .then(data => {
    console.log('Data:', data);
  })
  .catch(error => {
    console.error('Error:', error);
  });

import requests
import json
import time
 
API_KEY = "YOUR_API_KEY"
HOST = "api.scrapeless.com"
 
# Submit task
task_url = f"https://{HOST}/api/v1/scraper/request"
payload = json.dumps({
    "actor": "scraper.shopee",
    "input": {"url": "https://shopee.tw/a-i.10228173.24803858474"}
})
headers = {'Content-Type': 'application/json', 'x-api-token': API_KEY}
 
response = requests.post(task_url, headers=headers, data=payload)
 
# Handle response
if response.status_code == 200:
    print("Data:", response.json())
elif response.status_code == 201:
    task_id = response.json()["taskId"]
    print(f"Task queued. Polling ID: {task_id}")
 
    # Poll for results (max 10 attempts, 3s interval)
    max_retries = 10
    for _ in range(max_retries):
        result_url = f"https://{HOST}/api/v1/scraper/result/{task_id}"
        result_response = requests.get(result_url, headers=headers)
 
        if result_response.status_code == 200:
            print("Result:", result_response.json())
            break
        elif result_response.status_code == 201:
            print("Still processing. Retrying in 3s...")
            time.sleep(3)
        else:
            print(f"Error {result_response.status_code}: {result_response.text}")
            break
else:
    print(f"Request failed: {response.status_code} - {response.text}")
 

package main
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)
const (
    API_KEY = "YOUR_KEY"
    HOST    = "api.scrapeless.com"
)
type TaskResponse struct {
    TaskId string `json:"taskId"`
}
func main() {
    // Submit task
    payload, _ := json.Marshal(map[string]interface{}{
       "actor": "scraper.shopee",
       "input": map[string]string{
          "url": "https://shopee.tw/a-i.10228173.24803858474",
       },
    })
    req, _ := http.NewRequest(
       "POST",
       fmt.Sprintf("https://%s/api/v1/scraper/request", HOST),
       bytes.NewBuffer(payload),
    )
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-api-token", API_KEY)
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
       panic(err)
    }
    defer resp.Body.Close()
    body, _ := ioutil.ReadAll(resp.Body)
    if resp.StatusCode == 200 {
       fmt.Printf("Direct result: %s\n", body)
    } else if resp.StatusCode == 201 {
       var taskResp TaskResponse
       json.Unmarshal(body, &taskResp)
       // Polling logic
       for i := 0; i < 10; i++ {
          pollReq, _ := http.NewRequest("GET",
             fmt.Sprintf("https://%s/api/v1/scraper/result/%s", HOST, taskResp.TaskId), nil)
          pollReq.Header.Add("x-api-token", API_KEY)
          pollResp, err := client.Do(pollReq)
          if err != nil {
             continue
          }
          defer pollResp.Body.Close()
          if pollResp.StatusCode == 200 {
             result, _ := ioutil.ReadAll(pollResp.Body)
             fmt.Printf("Final result: %s\n", result)
             break
          }
          time.Sleep(3 * time.Second)
       }
    } else {
       fmt.Printf("Error %d: %s", resp.StatusCode, body)
    }
}

const axios = require('axios');
const API_KEY = 'YOUR_KEY';
const HOST = 'api.scrapeless.com';
 
async function runTask() {
  try {
    // Submit task
    const submitResp = await axios.post(
      `https://${HOST}/api/v1/scraper/request`,
      {
        actor: 'scraper.shopee',
        input: {
          url: 'https://shopee.tw/a-i.10228173.24803858474'
        }
      },
      {
        headers: {
          'x-api-token': API_KEY,
          'Content-Type': 'application/json'
        }
      }
    );
 
    if (submitResp.status === 200) {
      console.log('Direct result:', submitResp.data);
    } else if (submitResp.status === 201) {
      const taskId = submitResp.data.taskId;
      
      // Polling function
      const pollResult = async (attempts = 0) => {
        if (attempts > 10) throw new Error('Max retries reached');
        
        const resultResp = await axios.get(
          `https://${HOST}/api/v1/scraper/result/${taskId}`,
          { headers: { 'x-api-token': API_KEY } }
        );
 
        if (resultResp.status === 200) {
          console.log('Final result:', resultResp.data);
        } else if (resultResp.status === 201) {
          await new Promise(resolve => setTimeout(resolve, 3000));
          return pollResult(attempts + 1);
        } else {
          throw new Error(`Status ${resultResp.status}: ${resultResp.data}`);
        }
      };
      
      await pollResult();
    }
  } catch (error) {
    console.error('Error:', error.message);
  }
}
 
runTask();