scavio 0.22.0 → 0.23.1

package/README.md

@@ -2,7 +2,8 @@
 
 TypeScript SDK for the [Scavio API](https://scavio.dev?utm_source=npm-scavio-js&utm_medium=package&utm_campaign=readme) — real-time structured web
 data across 36 platforms on one API key, plus `extract()` to read
-any URL as clean Markdown.
+any URL as clean Markdown, and `extract.map()` / `extract.crawl()` /
+`extract.batch()` to map, crawl and batch-extract whole websites.
 
 Structured JSON in, structured JSON out. No per-site parsers to maintain.
 
@@ -14,6 +15,7 @@ Structured JSON in, structured JSON out. No per-site parsers to maintain.
 - **Ads transparency** — Google Ads Transparency Center, Meta Ad Library
 - **Social and video** — YouTube, TikTok, Instagram, Threads, X, LinkedIn, Reddit, Kuaishou
 - **Any other page** — `extract()` turns a URL into Markdown, plain text or raw HTML
+- **Whole websites** — `extract.map()` lists a site's URLs, `extract.crawl()` crawls a site, `extract.batch()` extracts a list of URLs in one job
 
 ## Install
 
@@ -103,6 +105,134 @@ boilerplate stripped. `text` is that markdown flattened to plain text. URLs are
 http(s) only, a bare host is upgraded to https, and loopback, private,
 link-local and cloud-metadata hosts are rejected with a 400.
 
+### Website map, crawl and batch extract (new in 0.23.0)
+
+`extract` is also a namespace: calling it reads one page, exactly as before
+(`client.extract({ url })` sends the same request it did in 0.22), and its
+methods work on whole sites and URL lists, with each page returned exactly
+like [Extract](https://scavio.dev/docs/extract?utm_source=npm-scavio-js&utm_medium=package&utm_campaign=readme).
+
+```typescript
+// Map: every URL on a site, from its sitemaps and start page. 1 credit.
+const map = await client.extract.map({
+  url: "https://example.com",
+  limit: 500,                    // 1-5,000, default 1,000 (plan caps apply)
+  sitemap: "include",            // "include" | "only" | "skip"
+  include_paths: ["/blog/**"],   // optional path globs
+});
+map.data.links;       // [{ url, source: "sitemap" | "page", lastmod? }]
+map.data.truncated;   // true when more URLs exist than `limit`
+
+// Crawl: start a job, then poll it (polling and cancelling are free).
+const job = await client.extract.crawl(
+  { url: "https://example.com/docs", max_pages: 50, max_depth: 3, format: "markdown" },
+  { idempotencyKey: "docs-crawl-2026-10-12" }, // optional; one is generated when omitted
+);
+job.data.id;          // "crawl_..."
+job.data.status_url;
+
+const page = await client.extract.crawlStatus(job.data.id, { limit: 25 });
+page.data.status;      // "queued" | "running" | "completed" | "failed" | "cancelled"
+page.data.pages;       // { discovered, queued, succeeded, failed, skipped }
+page.data.results;     // [{ url, depth, status, status_code, content, ... }]
+page.data.next_cursor; // pass as { cursor } for the next page, null at the end
+
+await client.extract.cancelCrawl(job.data.id); // 409 once the crawl has finished
+
+// Or wait for it: polls until done and returns every result in one response.
+const done = await client.extract.crawl(
+  { url: "https://example.com/docs", max_pages: 20 },
+  { wait: true, pollInterval: 2000, waitTimeout: 600_000 },
+);
+done.data.results.length;
+
+// Batch: extract a list of URLs in one job (results in input order).
+const batch = await client.extract.batch({
+  urls: ["https://example.com/a", "https://example.com/b"],
+  mode: "normal",
+});
+batch.data.invalid_urls; // rejected up front, never billed
+await client.extract.batchStatus(batch.data.id);
+await client.extract.cancelBatch(batch.data.id);
+```
+
+**Pricing.** Map costs 1 credit. Crawl and batch bill per **successful** page
+at Extract's price for the tier: `normal` 1, `advanced` 1, `ultra` 2. Failed
+and skipped pages are free, starting, polling and cancelling a job are free,
+and credits are taken page by page: if your balance runs out the job stops
+cleanly with `stopped_reason: "insufficient_credits"`.
+
+**Plan limits.**
+
+| Plan | Max pages per crawl | Active jobs | URLs per batch |
+|------|--------------------:|------------:|---------------:|
+| Free | 10 | 1 | 10 |
+| PAYG | 100 | 1 | 50 |
+| Project | 500 | 2 | 100 |
+| Bootstrap | 2,000 | 3 | 500 |
+| Startup | 5,000 | 5 | 1,000 |
+| Growth | 10,000 | 10 | 1,000 |
+
+Starting a job above your plan's active-job limit is a 429 (`RateLimitError`)
+with `Retry-After`.
+
+**Behavior.** Crawl and map always obey the site's robots.txt. A crawl stays on
+the start URL's site (`allow_subdomains` opts into subdomains) and visits URLs
+under the start path first. Batch treats each URL like a single `extract()`
+call. Results are kept for 3 days after the job finishes (`expires_at`), up to
+2 MB per page and 250 MB per job, and a job runs for at most 6 hours.
+
+**`wait: true`.** `crawl()` and `batch()` poll the status endpoint every
+`pollInterval` ms (default 2,000) until the job is completed, failed or
+cancelled, then page through every cursor and return
+`{ data: { ...summary, results: [all], next_cursor: null }, created: {...} }`,
+where `created` is the 202 job handle (including `webhook_secret`, which is
+only returned on creation), as in the Python SDK (since 0.23.1). If the job is
+still running after `waitTimeout` ms (default 10 minutes) they throw
+`ScavioJobTimeoutError`; the job keeps running and the error carries
+`jobId`, `jobType` and `statusUrl` so you can keep polling or cancel it. For
+big crawls, prefer a webhook or your own polling loop.
+
+**Retries and idempotency.** The SDK retries 429/5xx and network errors.
+`crawl()` and `batch()` always send an `Idempotency-Key`: yours when you pass
+`idempotencyKey`, otherwise a random UUID generated for that call and reused on
+every retry of it (since 0.23.1). Repeating a POST with the same key within 24
+hours returns the original job, so a retried start never begins a second,
+billed one. Pass your own key to dedupe across calls or processes. Plain
+`extract()` and `map()` are not jobs and send no key.
+
+#### Completion webhooks
+
+Pass `webhook_url` (https) to `crawl()` or `batch()` and Scavio POSTs the job
+summary there when it completes, fails or is cancelled (retried at 0 s, 30 s
+and 5 min). The signing secret comes back once, as `job.data.webhook_secret`.
+Each delivery is signed with
+`Scavio-Signature: t=<unix>,v1=<hex HMAC-SHA256 of "<t>.<raw body>">`; verify
+it against the **raw** body with `verifyWebhook` (async, Web Crypto, so it runs
+on Node 18+, Deno, Bun and edge runtimes):
+
+```typescript
+import { verifyWebhook } from "scavio";
+
+// e.g. a Next.js / Hono / Workers route handler
+export async function POST(req: Request) {
+  const raw = await req.text();
+  const ok = await verifyWebhook(
+    process.env.SCAVIO_WEBHOOK_SECRET!,      // the job's webhook_secret
+    req.headers.get("Scavio-Signature"),
+    raw,
+    300,                                     // max signature age in seconds (default)
+  );
+  if (!ok) return new Response("bad signature", { status: 401 });
+  const event = JSON.parse(raw);
+  // event.id, event.status, ...
+  return new Response("ok");
+}
+```
+
+`verifyWebhook` returns `false` (never throws) for a missing, malformed,
+tampered or stale signature.
+
 ### Google
 
 Each method hits its own `/api/v2/google*` endpoint and returns Google's full
@@ -534,6 +664,10 @@ await client.tiktok.userPosts({ sec_user_id: "abc123", count: 30 });
 // Video details
 await client.tiktok.video({ video_id: "vid123" });
 
+// Video transcript: timestamped segments and full text (video_id or url;
+// optional 2-letter language). Caption-less videos return available: false.
+await client.tiktok.videoTranscript({ video_id: "7609177768793787679" });
+
 // Video comments
 await client.tiktok.videoComments({ video_id: "vid123", count: 20 });
 
@@ -1225,7 +1359,8 @@ All error classes:
 | `InsufficientCreditsError` | 402 | No credits remaining |
 | `NotFoundError` | 404 | No data for that id (see TikTok Shop above) |
 | `RateLimitError` | 429 | Rate limit exceeded |
-| `ScavioAPIError` | other | Catch-all (has `.statusCode`) |
+| `ScavioAPIError` | other | Catch-all (has `.statusCode`; a 409 from cancelling a finished job lands here) |
+| `ScavioJobTimeoutError` | — | `crawl()`/`batch()` with `wait: true` outlived `waitTimeout`; carries `jobId` |
 
 Threads and Kuaishou answer a missing or conflicting identifier with **422**, not
 400 — those routes have no 400 at all. Both map to `BadRequestError`, so one

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -30,6 +40,7 @@ __export(index_exports, {
   CostcoNamespace: () => CostcoNamespace,
   DEFAULT_MAX_REQUESTS_PER_SECOND: () => DEFAULT_MAX_REQUESTS_PER_SECOND,
   EbayNamespace: () => EbayNamespace,
+  ExtractNamespace: () => ExtractNamespace,
   G2Namespace: () => G2Namespace,
   GlassdoorNamespace: () => GlassdoorNamespace,
   GoogleAdsNamespace: () => GoogleAdsNamespace,
@@ -57,6 +68,7 @@ __export(index_exports, {
   ScavioAPIError: () => ScavioAPIError,
   ScavioConnectionError: () => ScavioConnectionError,
   ScavioError: () => ScavioError,
+  ScavioJobTimeoutError: () => ScavioJobTimeoutError,
   ScavioTimeoutError: () => ScavioTimeoutError,
   TargetNamespace: () => TargetNamespace,
   ThreadsNamespace: () => ThreadsNamespace,
@@ -68,7 +80,8 @@ __export(index_exports, {
   XNamespace: () => XNamespace,
   YelpNamespace: () => YelpNamespace,
   YouTubeNamespace: () => YouTubeNamespace,
-  ZillowNamespace: () => ZillowNamespace
+  ZillowNamespace: () => ZillowNamespace,
+  verifyWebhook: () => verifyWebhook
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -155,6 +168,22 @@ var ScavioAPIError = class extends ScavioError {
     this.responseBody = responseBody;
   }
 };
+var ScavioJobTimeoutError = class extends ScavioError {
+  constructor(jobType, jobId, statusUrl, lastStatus) {
+    super(
+      `${jobType} ${jobId} was still ${lastStatus} when the wait timed out. It keeps running: poll extract.${jobType}Status("${jobId}") or cancel it.`
+    );
+    this.jobType = jobType;
+    this.jobId = jobId;
+    this.statusUrl = statusUrl;
+    this.lastStatus = lastStatus;
+    this.name = "ScavioJobTimeoutError";
+  }
+  jobType;
+  jobId;
+  statusUrl;
+  lastStatus;
+};
 
 // src/retry.ts
 var DEFAULT_RETRY_STATUSES = /* @__PURE__ */ new Set([
@@ -203,7 +232,7 @@ function parseRetryAfter(header) {
 var BASE_URL = "https://api.scavio.dev";
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_MAX_RETRIES = 2;
-var SDK_VERSION = true ? "0.22.0" : "0.0.0";
+var SDK_VERSION = true ? "0.23.1" : "0.0.0";
 var USER_AGENT = `scavio-js/${SDK_VERSION}`;
 function isServerRuntime() {
   const g = globalThis;
@@ -261,9 +290,18 @@ function getHeader(response, name) {
   }
   return null;
 }
+function buildQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.append(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
 async function request(options) {
-  const url = `${options.baseUrl}${options.path}`;
-  const headers = buildHeaders(options.apiKey);
+  const url = `${options.baseUrl}${options.path}${buildQuery(options.query)}`;
+  const headers = { ...buildHeaders(options.apiKey), ...options.headers };
   const retry = makeRetryConfig(
     options.maxRetries ?? DEFAULT_MAX_RETRIES
   );
@@ -525,6 +563,14 @@ var TikTokNamespace = class {
   async video(options) {
     return this.client._post("/api/v1/tiktok/video", options);
   }
+  /**
+   * Spoken-word transcript of a TikTok video, as timestamped segments and
+   * full text. Pass `video_id` or `url`. Videos with no spoken captions
+   * (music, dance, muted clips) return `available: false`. 1 credit.
+   */
+  async videoTranscript(options) {
+    return this.client._post("/api/v1/tiktok/video/transcript", options);
+  }
   async videoComments(options) {
     return this.client._post("/api/v1/tiktok/video/comments", options);
   }
@@ -2945,10 +2991,135 @@ var MercadoLibreNamespace = class {
   }
 };
 
+// src/namespaces/extract.ts
+var TERMINAL = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+var DEFAULT_POLL_INTERVAL = 2e3;
+var DEFAULT_WAIT_TIMEOUT = 6e5;
+var COLLECT_PAGE_SIZE = 100;
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function randomUUID() {
+  const g = globalThis;
+  if (typeof g.crypto?.randomUUID === "function") return g.crypto.randomUUID();
+  const nodeCrypto = await import("crypto");
+  return nodeCrypto.randomUUID();
+}
+var ExtractNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /**
+   * List a site's page URLs, gathered from its sitemaps and its start page,
+   * deduplicated, filtered by path and limited. Pages disallowed by the
+   * site's robots.txt are left out. 1 credit on the normal tier.
+   */
+  async map(options) {
+    return await this.client._post("/api/v1/extract/map", options);
+  }
+  async crawl(options, request2 = {}) {
+    return this.start("crawl", options, request2);
+  }
+  /** A crawl's progress and its page results, paged by cursor. Free. */
+  async crawlStatus(id, query) {
+    return this.status("crawl", id, query);
+  }
+  /**
+   * Stop a queued or running crawl. No further pages are fetched or billed;
+   * results so far stay available. A finished crawl answers 409. Free.
+   */
+  async cancelCrawl(id) {
+    return this.cancel("crawl", id);
+  }
+  async batch(options, request2 = {}) {
+    return this.start("batch", options, request2);
+  }
+  /** A batch's progress and its page results in input order, paged by cursor. Free. */
+  async batchStatus(id, query) {
+    return this.status("batch", id, query);
+  }
+  /** Stop a queued or running batch. A finished batch answers 409. Free. */
+  async cancelBatch(id) {
+    return this.cancel("batch", id);
+  }
+  async start(type, body, request2) {
+    const headers = { "Idempotency-Key": request2.idempotencyKey ?? await randomUUID() };
+    const created = await this.client._post(
+      `/api/v1/extract/${type}`,
+      body,
+      headers
+    );
+    if (!request2.wait) return created;
+    const done = await this.waitFor(type, created.data.id, created.data.status_url, request2);
+    return { ...done, created: created.data };
+  }
+  async status(type, id, query = {}) {
+    return await this.client._get(`/api/v1/extract/${type}/${encodeURIComponent(id)}`, {
+      cursor: query.cursor,
+      limit: query.limit,
+      status: query.status,
+      include_content: query.include_content
+    });
+  }
+  async cancel(type, id) {
+    return await this.client._delete(
+      `/api/v1/extract/${type}/${encodeURIComponent(id)}`
+    );
+  }
+  async waitFor(type, id, statusUrl, request2) {
+    const interval = request2.pollInterval ?? DEFAULT_POLL_INTERVAL;
+    const deadline = Date.now() + (request2.waitTimeout ?? DEFAULT_WAIT_TIMEOUT);
+    for (; ; ) {
+      const probe = await this.status(type, id, { limit: 1, include_content: false });
+      if (TERMINAL.has(probe.data.status)) break;
+      if (Date.now() + interval > deadline) {
+        throw new ScavioJobTimeoutError(type, id, statusUrl, probe.data.status);
+      }
+      await sleep2(interval);
+    }
+    const results = [];
+    let cursor;
+    let last;
+    do {
+      last = await this.status(type, id, { cursor, limit: COLLECT_PAGE_SIZE });
+      results.push(...last.data.results);
+      cursor = last.data.next_cursor ?? void 0;
+    } while (cursor);
+    return { data: { ...last.data, results, next_cursor: null } };
+  }
+};
+
 // src/client.ts
 var DEFAULT_MAX_REQUESTS_PER_SECOND = 1;
 var MAX_REQUESTS_PER_SECOND = 50;
-var Scavio = class {
+var ScavioCore = class {
+  /**
+   * Read ANY web page and get it back as readability Markdown (the default),
+   * plain text, or raw HTML. Returns `{ url, format, mode, content,
+   * content_length }`.
+   *
+   * Extract is a core endpoint, not a platform: `scavio.extract({ url })`
+   * reads one page, and `scavio.extract.map()` / `.crawl()` / `.batch()` work
+   * on whole sites and URL lists.
+   *
+   * Credits are a function of `mode`, not a flat per-call constant:
+   * "normal" costs 1, "advanced" costs 1, "ultra" costs 2. Billing happens
+   * only on a successful extraction - a dead link, bot wall or timeout costs
+   * nothing.
+   *
+   * Start on "normal". Move to "advanced" when the page builds its content in
+   * the browser, and to "ultra" only when a bot wall blocks the other two.
+   *
+   * @example
+   * const page = await scavio.extract({ url: "https://example.com/pricing" });
+   * console.log(page.content);
+   */
+  async extract(options) {
+    return this._post("/api/v1/extract", options);
+  }
+};
+var Scavio = class extends ScavioCore {
   google;
   amazon;
   walmart;
@@ -2991,6 +3162,7 @@ var Scavio = class {
   maxRetries;
   rateLimiter;
   constructor(config) {
+    super();
     this.apiKey = config?.apiKey ?? process.env.SCAVIO_API_KEY ?? "";
     if (!this.apiKey) {
       throw new MissingAPIKeyError();
@@ -3041,9 +3213,19 @@ var Scavio = class {
     this.realtor = new RealtorNamespace(this);
     this.rightmove = new RightmoveNamespace(this);
     this.mercadolibre = new MercadoLibreNamespace(this);
+    const extractNs = new ExtractNamespace(this);
+    this.extract = Object.assign(ScavioCore.prototype.extract.bind(this), {
+      map: extractNs.map.bind(extractNs),
+      crawl: extractNs.crawl.bind(extractNs),
+      crawlStatus: extractNs.crawlStatus.bind(extractNs),
+      cancelCrawl: extractNs.cancelCrawl.bind(extractNs),
+      batch: extractNs.batch.bind(extractNs),
+      batchStatus: extractNs.batchStatus.bind(extractNs),
+      cancelBatch: extractNs.cancelBatch.bind(extractNs)
+    });
   }
   /** @internal */
-  async _post(path, body) {
+  async _post(path, body, headers) {
     return request({
       method: "POST",
       path,
@@ -3052,11 +3234,12 @@ var Scavio = class {
       timeout: this.timeout,
       maxRetries: this.maxRetries,
       rateLimiter: this.rateLimiter,
-      body
+      body,
+      headers
     });
   }
   /** @internal */
-  async _get(path) {
+  async _get(path, query) {
     return request({
       method: "GET",
       path,
@@ -3064,39 +3247,73 @@ var Scavio = class {
       baseUrl: this.baseUrl,
       timeout: this.timeout,
       maxRetries: this.maxRetries,
+      rateLimiter: this.rateLimiter,
+      query
+    });
+  }
+  /** @internal */
+  async _delete(path) {
+    return request({
+      method: "DELETE",
+      path,
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      timeout: this.timeout,
+      maxRetries: this.maxRetries,
       rateLimiter: this.rateLimiter
     });
   }
   async search(options) {
     return this.google.search(options);
   }
-  /**
-   * Read ANY web page and get it back as readability Markdown (the default),
-   * plain text, or raw HTML. Returns `{ url, format, mode, content,
-   * content_length }`.
-   *
-   * This is a core endpoint, not a platform, so it lives on the client itself:
-   * `scavio.extract({ url })`, never `scavio.extract.extract()`.
-   *
-   * Credits are a function of `mode`, not a flat per-call constant:
-   * "normal" costs 1, "advanced" costs 1, "ultra" costs 2. Billing happens
-   * only on a successful extraction - a dead link, bot wall or timeout costs
-   * nothing.
-   *
-   * Start on "normal". Move to "advanced" when the page builds its content in
-   * the browser, and to "ultra" only when a bot wall blocks the other two.
-   *
-   * @example
-   * const page = await scavio.extract({ url: "https://example.com/pricing" });
-   * console.log(page.content);
-   */
-  async extract(options) {
-    return this._post("/api/v1/extract", options);
-  }
   async getUsage() {
     return this._get("/api/v1/usage");
   }
 };
+
+// src/webhook.ts
+async function verifyWebhook(secret, header, body, toleranceSec = 300) {
+  if (!secret || !header) return false;
+  const parts = {};
+  for (const piece of header.split(",")) {
+    const i = piece.indexOf("=");
+    if (i > 0) parts[piece.slice(0, i).trim()] = piece.slice(i + 1).trim();
+  }
+  const t = Number(parts.t);
+  const v1 = parts.v1;
+  if (!parts.t || !Number.isFinite(t) || !v1 || !/^[0-9a-f]+$/i.test(v1)) return false;
+  if (Math.abs(Math.floor(Date.now() / 1e3) - t) > toleranceSec) return false;
+  const subtle = await getSubtle();
+  const enc = new TextEncoder();
+  const key = await subtle.importKey(
+    "raw",
+    enc.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const bodyBytes = typeof body === "string" ? enc.encode(body) : body;
+  const prefix = enc.encode(`${t}.`);
+  const message = new Uint8Array(prefix.length + bodyBytes.length);
+  message.set(prefix, 0);
+  message.set(bodyBytes, prefix.length);
+  const mac = new Uint8Array(await subtle.sign("HMAC", key, message));
+  let expected = "";
+  for (const b of mac) expected += b.toString(16).padStart(2, "0");
+  return timingSafeEqualHex(expected, v1.toLowerCase());
+}
+function timingSafeEqualHex(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+async function getSubtle() {
+  const g = globalThis;
+  if (g.crypto?.subtle) return g.crypto.subtle;
+  const nodeCrypto = await import("crypto");
+  return nodeCrypto.webcrypto.subtle;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AirbnbNamespace,
@@ -3109,6 +3326,7 @@ var Scavio = class {
   CostcoNamespace,
   DEFAULT_MAX_REQUESTS_PER_SECOND,
   EbayNamespace,
+  ExtractNamespace,
   G2Namespace,
   GlassdoorNamespace,
   GoogleAdsNamespace,
@@ -3136,6 +3354,7 @@ var Scavio = class {
   ScavioAPIError,
   ScavioConnectionError,
   ScavioError,
+  ScavioJobTimeoutError,
   ScavioTimeoutError,
   TargetNamespace,
   ThreadsNamespace,
@@ -3147,6 +3366,7 @@ var Scavio = class {
   XNamespace,
   YelpNamespace,
   YouTubeNamespace,
-  ZillowNamespace
+  ZillowNamespace,
+  verifyWebhook
 });
 //# sourceMappingURL=index.cjs.map