example.js

/**
 * Amazon Scraper — Scrapeless Scraping API (Node.js example)
 *
 * Docs:  https://apidocs.scrapeless.com/doc-857373
 * Token: https://app.scrapeless.com/passport/login?redirect=/quick-start
 *
 * The Amazon actor supports four scrape types selected via `input.type`:
 *   product | seller | keywords | rufus
 *
 * Run (Node.js 18+, uses the built-in fetch):
 *   export SCRAPELESS_API_TOKEN="your_api_token"
 *   node example.js            # defaults to the "product" type
 *   node example.js keywords   # or pass a type: product | seller | keywords | rufus
 */

const API_URL = "https://api.scrapeless.com/api/v1/scraper/request";
const API_TOKEN = process.env.SCRAPELESS_API_TOKEN || "YOUR_API_TOKEN";

// Ready-to-use input payloads for each scrape type.
const SAMPLE_INPUTS = {
  product: {
    type: "product",
    url: "https://www.amazon.com/dp/B0BQXHK363",
    zip_code: "",
  },
  seller: {
    type: "seller",
    url: "https://www.amazon.com/sp?seller=A2XZ7JICGUQ1CX",
    zip_code: "",
  },
  keywords: {
    type: "keywords",
    keywords: "Iphone+14+Pro+512GB",
    page: "1",
    domain: "com",
    zip_code: "",
  },
  rufus: {
    type: "rufus",
    keywords: "macbook",
    domain: "www.amazon.es",
    page: "1",
  },
};

async function scrape(scrapeType) {
  const input = SAMPLE_INPUTS[scrapeType];
  if (!input) {
    throw new Error(`Unknown type '${scrapeType}'. Choose one of: ${Object.keys(SAMPLE_INPUTS).join(", ")}`);
  }

  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-token": API_TOKEN,
    },
    body: JSON.stringify({ actor: "scraper.amazon", input }),
  });

  // The Amazon actor distinguishes scenarios by HTTP status code.
  switch (response.status) {
    case 200: {
      // Synchronous success: the body is the scraped data (shape depends on type).
      const data = await response.json();
      console.log(`[200] Success — '${scrapeType}' data received.`);
      summarize(scrapeType, data);
      return data;
    }
    case 201: {
      // Task accepted but still running. Retrieve it later by task id
      // (async retrieval / webhook — see the official documentation).
      const body = await response.json();
      console.log(`[201] Task in progress — message: ${body.message}, taskId: ${body.taskId}`);
      console.log("      Fetch the result later using the task id (see docs).");
      return body;
    }
    case 400: {
      // Scraping failed — inspect the error code and message.
      const body = await response.json();
      console.log(`[400] Bad request — code: ${body.code}, message: ${body.message}`);
      return body;
    }
    default: {
      const text = await response.text();
      console.log(`[${response.status}] Unexpected response:\n${text}`);
      throw new Error(`Unexpected status ${response.status}`);
    }
  }
}

function summarize(scrapeType, data) {
  if (scrapeType === "product") {
    console.log(`  ASIN:  ${data.asin}`);
    console.log(`  Brand: ${data.brand}`);
    console.log(`  Price: ${data.final_price}  (${data.availability})`);
  } else if (scrapeType === "keywords") {
    const organic = (data.result && data.result.organic) || [];
    console.log(`  keyword: ${data.keyword} page: ${data.page} — ${organic.length} organic results`);
    for (const item of organic.slice(0, 3)) {
      console.log(`    - ${item.title} :: ${item.price}`);
    }
  } else {
    console.log(`  ${scrapeType} keys: ${Object.keys(data).slice(0, 10).join(", ")}`);
  }
  console.log("\n  Raw response (truncated to 1500 chars):");
  console.log("  " + JSON.stringify(data).slice(0, 1500));
}

const type = process.argv[2] || "product";
scrape(type).catch((err) => {
  console.error(err.message);
  process.exit(1);
});