### Install Scrapeit Cloud NodeJS SDK

Source: https://github.com/hasdata/hasdata-node-sdk/blob/main/README.md

This snippet shows the command to install the Scrapeit Cloud NodeJS SDK using npm. It is a prerequisite for using the SDK in your Node.js project.

```bash
npm i @scrapeit-cloud/scrapeit-cloud-node-sdk
```

--------------------------------

### Web Scraping with TypeScript SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

This example demonstrates how to use the Scrapeit SDK with TypeScript, leveraging full type definitions for parameters and responses. It shows the setup of scrape parameters, making a scraping request, and processing the response object. Basic error handling is included. This approach ensures type safety throughout the web scraping process.

```typescript
import ScrapeitCloud, { ScrapeitCloudAPIParams, ScrapeitCloudAPIResponse } from '@scrapeit-cloud/scrapeit-cloud-node-sdk';

const scrapeit = new ScrapeitCloud('your_api_key_here');

async function typescriptExample(): Promise<ScrapeitCloudAPIResponse> {
  const params: ScrapeitCloudAPIParams = {
    url: "https://example.com",
    screenshot: true,
    wait: 3000,
    wait_for: ".content",
    proxy_type: "datacenter",
    proxy_country: "US",
    block_resources: true,
    block_urls: ["*.jpg", "*.png"],
    headers: {
      "Accept-Language": "en-US"
    },
    extract_rules: {
      "title": "h1",
      "content": ".main-content"
    },
    js_scenario: [
      {
        wait_for: "#cookie-banner"
      },
      {
        click: ".accept-all"
      }
    ],
    window_height: 1080,
    window_width: 1920
  };

  try {
    const response: ScrapeitCloudAPIResponse = await scrapeit.scrape(params);

    console.log('Content:', response.content);
    console.log('Screenshot:', response.screenshot);
    console.log('Headers:', response.headers);
    console.log('Cookies:', response.cookies);

    return response;
  } catch (error) {
    if (error instanceof Error) {
      console.error('Scraping failed:', error.message);
    }
    throw error;
  }
}

typescriptExample();

```

--------------------------------

### Advanced Web Scraping with JavaScript SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

This example demonstrates a comprehensive production-grade web scraping process using the Scrapeit SDK in JavaScript. It includes configurations for proxies, resource blocking, custom headers, extraction rules, and executing JavaScript scenarios. The output includes extracted data, HTML content, cookies, headers, and an optional screenshot. Error handling for rate limits and invalid API keys is also included, along with a retry mechanism.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');
const fs = require('fs');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function advancedScraping() {
  try {
    const response = await scrapeit.scrape({
      url: "https://example.com/products",
      proxy_type: "residential",
      proxy_country: "US",
      screenshot: true,
      window_width: 1920,
      window_height: 1080,
      wait_for: ".product-grid",
      wait: 2000,
      block_resources: true,
      block_urls: ["*.woff", "*.ttf", "analytics.js"],
      headers: {
        "Accept-Language": "en-US,en;q=0.9",
        "User-Agent": "Mozilla/5.0"
      },
      extract_rules: {
        "product_names": "h2.product-name",
        "prices": ".price",
        "ratings": ".rating-score"
      },
      js_scenario: [
        {
          wait_for: ".cookie-consent"
        },
        {
          click: ".accept-cookies"
        },
        {
          scroll_y: 500
        },
        {
          wait: 1000
        }
      ]
    });

    // Process response
    console.log('Extraction:', response.extractedData);
    console.log('HTML length:', response.content.length);
    console.log('Cookies:', response.cookies);
    console.log('Headers:', response.headers);

    // Save screenshot
    if (response.screenshot) {
      fs.writeFileSync('result.png', Buffer.from(response.screenshot, 'base64'));
    }

    return response;
  } catch (error) {
    if (error.message.includes('rate limit')) {
      console.error('Rate limit exceeded, retry later');
    } else if (error.message.includes('invalid api key')) {
      console.error('Authentication failed, check API key');
    } else {
      console.error('Scraping error:', error.message);
    }
    throw error;
  }
}

// Execute with retry logic
async function scrapeWithRetry(maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await advancedScraping();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      console.log(`Retry ${i + 1}/${maxRetries}`);
      await new Promise(resolve => setTimeout(resolve, 2000));
    }
  }
}

scrapeWithRetry();

```

--------------------------------

### Extract Data with scrape() using Rules - Node.js SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

This example illustrates how to extract specific data from web pages into a structured JSON format using CSS selectors defined in `extract_rules`. It leverages the Node.js SDK and requires the '@scrapeit-cloud/scrapeit-cloud-node-sdk' package.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function extractData() {
  try {
    const response = await scrapeit.scrape({
      url: "https://example.com/products",
      extract_rules: {
        "title": "h1.product-title",
        "price": ".price-value",
        "description": ".product-description",
        "images": "img.product-image@src",
        "availability": ".stock-status"
      }
    });

    console.log('Extracted data:', response.extractedData);
    console.log('Raw HTML:', response.content);

    return response;
  } catch (error) {
    console.error('Extraction failed:', error.message);
  }
}

extractData();
```

--------------------------------

### Send Custom Headers with scrape() - Node.js SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

This example demonstrates how to send custom HTTP headers with scraping requests using the Node.js SDK. This is useful for authentication or simulating browser requests. It requires the '@scrapeit-cloud/scrapeit-cloud-node-sdk' package.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function customHeaders() {
  try {
    const response = await scrapeit.scrape({
      url: "https://api.example.com/data",
      headers: {
        "Authorization": "Bearer token123",
        "X-Custom-Header": "custom-value",
        "Accept-Language": "en-US"
      }
    });

    console.log('API response:', response.content);
    console.log('Response headers:', response.headers);

    return response;
  } catch (error) {
    console.error('Custom headers request failed:', error.message);
  }
}

customHeaders();
```

--------------------------------

### Initialize ScrapeitCloud SDK Client

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

Initializes the Scrapeit Cloud NodeJS SDK client using an API key. Includes error handling for missing API keys. Requires the '@scrapeit-cloud/scrapeit-cloud-node-sdk' package.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

// Initialize with API key
const scrapeit = new ScrapeitSDK('your_api_key_here');

// Error handling for missing API key
try {
  const client = new ScrapeitSDK();
} catch (error) {
  console.error(error.message); // "API Key is not provided"
}
```

--------------------------------

### Basic Web Scraping with Scrapeit Cloud NodeJS SDK

Source: https://github.com/hasdata/hasdata-node-sdk/blob/main/README.md

Demonstrates how to initialize the Scrapeit SDK with an API key and make a scraping request for a given URL. It includes options for screenshots and proxy country/type. Error handling is also shown.

```javascript
import ScrapeitSDK from './index';

const main = async () => {
  const scrapeit = new ScrapeitSDK('INSERT_YOUR_API_KEY_HERE');

  try {
    const response = await scrapeit.scrape({
      "url": "https://example.com",
      "screenshot": true,
      "proxy_country": "US",
      "proxy_type": "datacenter"
    });

    console.log(response);
  } catch(e) {
    console.log(e.message);
  }
};

main();
```

--------------------------------

### Basic Web Scraping with Scrapeit SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

Performs basic web scraping to retrieve HTML content, headers, and cookies from a given URL. Handles potential scraping errors. Requires the '@scrapeit-cloud/scrapeit-cloud-node-sdk' package and an API key.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function basicScrape() {
  try {
    const response = await scrapeit.scrape({
      url: "https://example.com"
    });

    console.log(response.content); // HTML content
    console.log(response.headers); // Response headers
    console.log(response.cookies); // Cookies array

    return response;
  } catch (error) {
    console.error('Scraping failed:', error.message);
  }
}

basicScrape();
```

--------------------------------

### Configure Proxies for Scraping with Scrapeit SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

Demonstrates routing web scraping requests through different proxy types (datacenter, residential) and geographic locations (US, Germany). Handles errors during proxy-configured scraping. Requires '@scrapeit-cloud/scrapeit-cloud-node-sdk' and an API key.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function proxyExample() {
  try {
    // Use US datacenter proxy
    const datacenterResponse = await scrapeit.scrape({
      url: "https://example.com",
      proxy_type: "datacenter",
      proxy_country: "US"
    });

    // Use residential proxy from Germany
    const residentialResponse = await scrapeit.scrape({
      url: "https://example.com",
      proxy_type: "residential",
      proxy_country: "DE"
    });

    console.log('Datacenter result:', datacenterResponse.content);
    console.log('Residential result:', residentialResponse.content);

    return { datacenterResponse, residentialResponse };
  } catch (error) {
    console.error('Proxy scraping failed:', error.message);
  }
}

proxyExample();
```

--------------------------------

### Execute JavaScript Scenarios with scrape() - Node.js SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

This code demonstrates how to execute complex JavaScript scenarios, including user interactions like clicks, form fills, and scrolling, using the Node.js SDK. It's ideal for scraping dynamic websites. The '@scrapeit-cloud/scrapeit-cloud-node-sdk' package is a prerequisite.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function jsScenario() {
  try {
    const response = await scrapeit.scrape({
      url: "https://example.com/search",
      js_scenario: [
        {
          wait_for: "#search-input"
        },
        {
          fill: ["#search-input", "laptop computers"]
        },
        {
          click: "#search-button"
        },
        {
          wait: 3000
        },
        {
          wait_for_and_click: ".load-more-button"
        },
        {
          scroll_y: 1000
        },
        {
          evaluate: "document.querySelector('.results').innerText"
        }
      ],
      screenshot: true
    });

    console.log('Scenario completed:', response.content);
    return response;
  } catch (error) {
    console.error('JavaScript scenario failed:', error.message);
  }
}

jsScenario();
```

--------------------------------

### Wait for Elements and Time Delays with Scrapeit SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

Implements waiting strategies for dynamic content, allowing the SDK to wait for a specific CSS selector to appear and an additional time delay before returning the page content. Handles errors during the waiting process. Requires '@scrapeit-cloud/scrapeit-cloud-node-sdk' and an API key.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function waitForElements() {
  try {
    // Wait for a specific CSS selector to appear
    const response = await scrapeit.scrape({
      url: "https://example.com/products",
      wait_for: ".product-list",
      wait: 5000 // Additional 5 second wait after element appears
    });

    console.log('Content loaded:', response.content);
    return response;
  } catch (error) {
    console.error('Wait failed:', error.message);
  }
}

waitForElements();
```

--------------------------------

### Capture Screenshot with Scrapeit SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

Captures a full-page screenshot of a webpage and saves it as a PNG file. The screenshot is returned as a base64-encoded string. Requires '@scrapeit-cloud/scrapeit-cloud-node-sdk', 'fs' module, and an API key. Supports specifying window dimensions.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');
const fs = require('fs');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function captureScreenshot() {
  try {
    const response = await scrapeit.scrape({
      url: "https://example.com",
      screenshot: true,
      window_width: 1920,
      window_height: 1080
    });

    // Screenshot is base64 encoded
    if (response.screenshot) {
      const buffer = Buffer.from(response.screenshot, 'base64');
      fs.writeFileSync('screenshot.png', buffer);
      console.log('Screenshot saved to screenshot.png');
    }

    return response;
  } catch (error) {
    console.error('Screenshot failed:', error.message);
  }
}

captureScreenshot();
```

--------------------------------

### Batch Scraping with Error Recovery in NodeJS SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

Implements a batch scraping function using the Scrapeit Cloud NodeJS SDK that iterates through a list of URLs, attempts to scrape each one, and collects both successful results and errors. It includes a delay between requests to respect rate limits and logs summary statistics of successful and failed scrapes.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

// Batch scraping with error recovery
async function batchScrape(urls) {
  const results = [];
  const errors = [];

  for (const url of urls) {
    try {
      const response = await scrapeit.scrape({ url });
      results.push({ url, success: true, data: response });
    } catch (error) {
      errors.push({ url, success: false, error: error.message });
      console.error(`Failed to scrape ${url}:`, error.message);
    }

    // Rate limiting delay
    await new Promise(resolve => setTimeout(resolve, 1000));
  }

  console.log(`Scraped ${results.length}/${urls.length} URLs successfully`);
  console.log(`Failed: ${errors.length} URLs`);

  return { results, errors };
}

const testUrls = [
  'https://example.com/page1',
  'https://example.com/page2',
  'https://example.com/page3'
];

batchScrape(testUrls);
```

--------------------------------

### Block Resources with scrape() - Node.js SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

This code snippet shows how to block specific resources (like images, CSS, fonts) during a scrape operation using the Node.js SDK. This can significantly speed up scraping and reduce bandwidth. It relies on the '@scrapeit-cloud/scrapeit-cloud-node-sdk' package.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function blockResources() {
  try {
    // Block all non-essential resources
    const response = await scrapeit.scrape({
      url: "https://example.com",
      block_resources: true,
      block_urls: [
        "*.jpg",
        "*.png",
        "*.gif",
        "google-analytics.com/*",
        "facebook.com/*"
      ]
    });

    console.log('Fast scrape completed:', response.content);
    return response;
  } catch (error) {
    console.error('Resource blocking failed:', error.message);
  }
}

blockResources();
```

--------------------------------

### Handle API Errors in NodeJS SDK

Source: https://context7.com/hasdata/hasdata-node-sdk/llms.txt

Demonstrates how to catch and handle various API errors returned by the Scrapeit Cloud NodeJS SDK during a single scrape operation. It checks for specific error messages related to authentication, rate limiting, timeouts, IP blocking, and insufficient credits, providing tailored console error messages and re-throwing the error for further handling.

```javascript
const ScrapeitSDK = require('@scrapeit-cloud/scrapeit-cloud-node-sdk');

const scrapeit = new ScrapeitSDK('your_api_key_here');

async function errorHandlingExample() {
  try {
    const response = await scrapeit.scrape({
      url: "https://example.com"
    });

    // Success - status: "ok"
    console.log('Content:', response.content);

  } catch (error) {
    // Handle specific error types
    const errorMessage = error.message.toLowerCase();

    if (errorMessage.includes('api key')) {
      console.error('Authentication error: Invalid or missing API key');
      // Update API key or check account
    } else if (errorMessage.includes('rate limit')) {
      console.error('Rate limit exceeded: Wait before retrying');
      // Implement exponential backoff
    } else if (errorMessage.includes('timeout')) {
      console.error('Request timeout: Page took too long to load');
      // Increase wait parameter or simplify request
    } else if (errorMessage.includes('blocked')) {
      console.error('IP blocked: Try different proxy type or country');
      // Switch proxy configuration
    } else if (errorMessage.includes('credits')) {
      console.error('Insufficient credits: Add more credits to account');
      // Prompt user to add credits
    } else {
      console.error('Unexpected error:', error.message);
      // Log for debugging
    }

    throw error;
  }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.