JS Client

npm install evomi-client

import { EvomiClient } from 'evomi-client';

const client = new EvomiClient({ apiKey: 'your-api-key' });

// Scrape a webpage
const result = await client.scrape('https://example.com');
console.log(result.content);

export EVOMI_API_KEY="your-api-key"

const client = new EvomiClient({ apiKey: 'your-api-key' });

const client = new EvomiClient({
  apiKey: 'your-api-key',
  baseUrl: 'https://custom.evomi.com'
});

const result = await client.scrape('https://example.com', {
  mode: 'auto',              // 'request', 'browser', or 'auto'
  output: 'markdown',        // 'html', 'markdown', 'screenshot', 'pdf'
  device: 'windows',         // 'windows', 'macos', 'android'
  proxyType: 'residential',
  proxyCountry: 'US',
  proxySessionId: 'abc123',
  waitUntil: 'domcontentloaded',
  aiEnhance: true,
  aiPrompt: 'Extract product data',
  aiSource: 'markdown',
  jsInstructions: [{ click: '.load-more' }],
  executeJs: 'window.scrollTo(0, document.body.scrollHeight)',
  waitSeconds: 2,
  screenshot: false,
  pdf: false,
  excludedTags: ['nav', 'footer'],
  excludedSelectors: ['.ads'],
  blockResources: ['image', 'stylesheet'],
  additionalHeaders: { 'X-Custom': 'value' },
  captureHeaders: true,
  networkCapture: [{ url_pattern: '/api/.*' }],
  asyncMode: false,
  configId: 'cfg_abc123',
  schemeId: 'sch_abc123',
  extractScheme: [{ label: 'title', type: 'content', selector: 'h1' }],
  storageId: 'stor_abc123',
  useDefaultStorage: false
});

const result = await client.crawl('example.com', {
  maxUrls: 100,
  depth: 2,
  urlPattern: '/blog/.*',
  scraperConfig: { mode: 'browser', output: 'markdown' },
  asyncMode: false,
});

const result = await client.mapWebsite('example.com', {
  sources: ['sitemap', 'commoncrawl'],
  maxUrls: 500,
  urlPattern: '/products/.*',
  checkIfLive: false,
  depth: 1,
  asyncMode: false,
});

// Single query
const result = await client.searchDomains('e-commerce platforms', {
  maxUrls: 20,
  region: 'us-en',
});

// Multiple queries (up to 10)
const result = await client.searchDomains(
  ['web scraping tools', 'data extraction services'],
  { maxUrls: 20, region: 'us-en' }
);

const result = await client.agentRequest(
  'Scrape example.com and extract all product prices'
);

const result = await client.getTaskStatus('abc123', 'scrape');
// taskType: 'scrape' | 'crawl' | 'map' | 'config_generate' | 'schema'

const configs = await client.listConfigs({
  page: 1,
  perPage: 20,
  sortBy: 'created_at',
  sortOrder: 'desc',
});

const config = await client.createConfig('Product Scraper', {
  mode: 'browser',
  output: 'markdown',
});

const config = await client.getConfig('cfg_abc123');

const config = await client.updateConfig('cfg_abc123', {
  name: 'New Name',
  config: { mode: 'request' },
});

await client.deleteConfig('cfg_abc123');

const config = await client.generateConfig(
  'Amazon Scraper',
  'Scrape product title and price from Amazon product pages'
);

const schemas = await client.listSchemas({
  page: 1,
  perPage: 20,
  sortBy: 'created_at',
  sortOrder: 'desc',
});

const schema = await client.createSchema(
  'Product Schema',
  {
    url: 'https://example.com/product',
    extract_scheme: [
      { label: 'title', type: 'content', selector: 'h1' },
      { label: 'price', type: 'content', selector: '.price' },
    ],
  },
  { test: true, fix: false }
);

const schema = await client.getSchema('sch_abc123');

const schema = await client.updateSchema(
  'sch_abc123',
  'Updated Schema',
  { url: '...', extract_scheme: [...] },
  { test: true }
);

await client.deleteSchema('sch_abc123');

const status = await client.getSchemaStatus('sch_abc123');

const schedules = await client.listSchedules({
  page: 1,
  perPage: 20,
  activeOnly: false,
});

const schedule = await client.createSchedule(
  'Daily Price Check',
  'cfg_abc123',
  1440,  // Daily (in minutes)
  { startTime: '09:00', stopOnError: true }
);

const schedule = await client.getSchedule('sched_abc123');

const schedule = await client.updateSchedule('sched_abc123', {
  name: 'New Name',
  intervalMinutes: 720,
});

await client.deleteSchedule('sched_abc123');

await client.toggleSchedule('sched_abc123');

const runs = await client.listScheduleRuns('sched_abc123', {
  page: 1,
  perPage: 20,
});

const configs = await client.listStorageConfigs();

// S3-compatible storage
const storage = await client.createStorageConfig(
  'My S3',
  's3_compatible',
  {
    bucket: 'my-bucket',
    region: 'us-east-1',
    access_key: '...',
    secret_key: '...',
  },
  { setAsDefault: true }
);

// Google Cloud Storage
const storage = await client.createStorageConfig(
  'My GCS',
  'gcs',
  { bucket: 'my-bucket', credentials_json: '...' }
);

// Azure Blob Storage
const storage = await client.createStorageConfig(
  'My Azure',
  'azure_blob',
  { container: 'my-container', connection_string: '...' }
);

const storage = await client.updateStorageConfig('stor_abc123', {
  name: 'Renamed Storage',
  setAsDefault: true,
});

await client.deleteStorageConfig('stor_abc123');

const data = await client.getPublicApi();
// Returns proxy credentials and product information

const data = await client.getProxyData();
// Returns: { products: { rp: {...}, sdc: {...}, mp: {...} }, ... }

const options = await client.getTargetingOptions();

const data = await client.getScraperData();

const data = await client.getBrowserData();

const result = await client.rotateSession('abc12345', 'rp');
// product: 'rpc', 'rp', 'sdc', 'mp'

const proxies = await client.generateProxies({
  product: 'rp',
  countries: 'US,GB,DE',
  city: 'New York',
  session: 'sticky',
  amount: 10,
  protocol: 'http',
  lifetime: 30,
  adblock: true,
});
// Returns plain text, one proxy per line

const info = await client.getAccountInfo();
console.log(info.credits);

import { WebhookConfig } from 'evomi-client';

// Discord webhook
const webhook = new WebhookConfig({
  url: 'https://discord.com/api/webhooks/...',
  webhookType: 'discord',
  events: ['completed', 'failed'],
});

// Custom webhook with HMAC signature
const webhook = new WebhookConfig({
  url: 'https://your-server.com/webhook',
  webhookType: 'custom',
  events: ['completed'],
  secret: 'your-secret-key',
});

import { EvomiClient, WebhookConfig } from 'evomi-client';

const client = new EvomiClient({ apiKey: 'your-api-key' });

const webhook = new WebhookConfig({
  url: 'https://discord.com/api/webhooks/...',
  webhookType: 'discord',
  events: ['completed', 'failed'],
});

const result = await client.scrape('https://example.com', {
  mode: 'browser',
  webhook,
});

// With crawl
const result = await client.crawl('example.com', {
  maxUrls: 100,
  webhook,
});

// With mapWebsite
const result = await client.mapWebsite('example.com', {
  webhook,
});

// With searchDomains
const result = await client.searchDomains('e-commerce platforms', {
  webhook,
});

const schedule = await client.createSchedule(
  'Daily Price Check',
  'cfg_abc123',
  1440,
  { startTime: '09:00', stopOnError: true, webhook }
);

import { EvomiClient, ProxyType, ProxyProtocol } from 'evomi-client';

const client = new EvomiClient({ apiKey: 'your-api-key' });

// Build a proxy string for US residential proxy
const proxyString = await client.buildProxyString({
  proxyType: ProxyType.RESIDENTIAL,
  country: 'US',
  session: 'abc12345'
});
console.log(proxyString);
// Output: http://user:pass_country-US_session-abc12345@rp.evomi.com:1000

import { ProxyConfig, ProxyType, ProxyProtocol } from 'evomi-client';

const config = new ProxyConfig({
  proxyType: ProxyType.RESIDENTIAL,
  protocol: ProxyProtocol.HTTP,
  country: 'US',
  city: 'New York',
  username: 'your-username',
  password: 'your-password'
});

const proxyString = config.buildProxyString();

try {
  const result = await client.scrape('https://example.com');
} catch (error) {
  console.error('Scraping failed:', error.message);
}

console.log(result._credits_used);
console.log(result._credits_remaining);