@zenrows/cli 1.5.0 → 1.5.1

package/README.md

@@ -37,8 +37,8 @@ that endpoint with extraction parameters, not a separate product.
 | Command | What it does | Status (this build) |
 | --- | --- | --- |
 | `zenrows fetch` | Fetch — retrieve a protected page | **available** — `GET https://api.zenrows.com/v1/` |
-| `zenrows extract` | Extract — `extract=auto` (domain-gated open beta; falls back to Autoparse) / CSS / Markdown | **beta** — same `/v1/` |
-| `zenrows batch` | Batch — fan out over many URLs | beta — cloud works with beta access; local validate/estimate always |
+| `zenrows extract` | Extract: `extract=auto` (any prepared domain; falls back to Autoparse on one not prepared yet), CSS, or Markdown | available, same `/v1/` |
+| `zenrows batch` | Batch: fan out over many URLs | **available**: `https://async.api.zenrows.com/v1`; local validate/estimate need no key |
 | `zenrows crawl` | Crawl (new) — collect the URLs behind one start page, optionally with each page's HTML | **available** — `https://api.zenrows.com/v1/crawls` |
 | `zenrows browser` | Browser Sessions REST API (same backend as MCP `browser_*`) | **available** — escalation-only; bills by bandwidth + time |
 | `zenrows mcp` | MCP server config (remote + local) | **available** |
@@ -123,12 +123,11 @@ zenrows extract <url> --outputs emails,links                            # built-
 zenrows extract <url> --output markdown
 ```
 
-## 9. Batch (beta)
+## 9. Batch
 
 Zenrows **Batch** (`https://async.api.zenrows.com/v1`) fans a
-protected fetch/extract out over many URLs. It is a real product in
-**beta**: the cloud subcommands work once your API key has
-beta access; without it the API returns `BATCH_ACCESS_DENIED`. Local spec
+protected fetch/extract out over many URLs. The cloud subcommands work
+with any active API key and spend the same credits as Fetch. Local spec
 validation + credit estimation always work (no key needed).
 
 ```bash
@@ -141,8 +140,7 @@ zenrows batch cancel <job-id>                        # stop an in-flight run
 
 `jobs.jsonl` is one JSON object per line, each with a `url` (plus optional
 per-line overrides like `js_render`, `premium_proxy`, `proxy_country`,
-`extract`). Request beta access from Zenrows to run in the cloud; until then,
-validate/estimate locally or fan out with `zenrows fetch` per URL.
+`extract`). Validate and estimate locally first, then submit with `create`.
 
 **Extract in Batch.** Set `"extract": "auto"` on a line to run that URL through
 Extract — structured data instead of raw HTML:

package/agent-plugin/skills/batch-jobs/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: batch-jobs
-description: Scale protected fetch/extract over many URLs via Zenrows MCP batch_* tools (beta).
+description: Scale protected fetch/extract over many URLs via Zenrows MCP batch_* tools.
 version: 0.1.0
 ---
 
@@ -9,8 +9,8 @@ version: 0.1.0
 Process large workloads asynchronously. Batch is where Zenrows' high-scale
 anti-bot advantage becomes obvious — thousands to millions of URLs.
 
-> Status: **beta**. Cloud Batch lives on `async.api.zenrows.com/v1`. Without
-> beta access the API returns `BATCH_ACCESS_DENIED`. Do not fake a successful
+> Cloud Batch lives on `async.api.zenrows.com/v1`. A 403 maps to
+> `BATCH_ACCESS_DENIED`. Do not fake a successful
 > run. This is **not** `browser_batch` (that batches browser actions in one
 > session).
 

package/agent-plugin/skills/cost-control/SKILL.md

@@ -18,7 +18,7 @@ These multipliers apply when you enable the flags (on `scrape` or `extract`):
 - Premium proxies (`premium_proxy`): **10×**
 - Both: **25×**
 
-`extract` `mode=auto` is **open beta** and currently free; billing may apply
+`extract` `mode=auto` is currently free; billing may apply
 later. Do not promise permanent free extract pricing. Autoparse / CSS still
 follow the multipliers above when stealth flags are set.
 
@@ -32,7 +32,6 @@ Always call `browser_close`. Prefer `scrape` / `extract` when they can do the jo
 
 Batch is usually better at **scale** (many URLs) than fan-out of per-URL tool
 calls. Validate one URL with `scrape`/`extract` first, then `batch_create`.
-Batch access may be beta-gated (`BATCH_ACCESS_DENIED`).
 
 ## Tactics
 

package/agent-plugin/skills/extract/SKILL.md

@@ -20,10 +20,10 @@ extract({ url, mode: "css", css_extractor: '{"title":"h1","price":".price"}' })
 extract({ url, proxy_country: "US" })               # geo-targeted
 ```
 
-`mode=auto` (`extract=auto`) is **open beta**: richest on enabled domains,
-currently free; billing may apply later. If the domain is not enabled (AUTH010)
-or not prepared yet (REQS007), the tool retries once with Autoparse by default
-(`fallback_autoparse`).
+`mode=auto` (`extract=auto`) works on any domain Zenrows has prepared, with any
+key, and is currently free; billing may apply later. If the
+domain is not enabled (AUTH010) or not prepared yet (REQS007), the tool retries
+once with Autoparse by default (`fallback_autoparse`).
 
 Every mode uses Adaptive Stealth Mode by default: pass just the URL, even for
 protected or dynamic sites. Set `js_render` or `premium_proxy` only to force a
@@ -45,7 +45,7 @@ scrape({ url, outputs: "emails,links" })            # or "*" for all built-ins
 
 ## When to use which
 
-- **`mode=auto`**: site-tailored fields on beta-enabled domains.
+- **`mode=auto`**: site-tailored fields on any prepared domain.
 - **`mode=autoparse`**: any website; also the automatic AUTH010 / REQS007 fallback.
 - **`mode=css`**: known fields/selectors; deterministic.
 - **Markdown via `scrape`**: feed clean content to an LLM yourself.

package/agent-plugin/skills/zenrows/SKILL.md

@@ -42,7 +42,7 @@ If the user has many URLs (bulk):
   → Use Batch.                      (validate one page with scrape/extract first,
                                      then batch_create → batch_status → batch_results)
                                      Prefer Batch over fan-out of scrape/extract
-                                     per URL for bulk work (may be beta-gated).
+                                     per URL for bulk work.
                                      Cancel with batch_cancel when needed.
 
 If the user needs login, clicks, forms, sessions, or persistent state:
@@ -66,8 +66,8 @@ If the user needs login, clicks, forms, sessions, or persistent state:
 | Primitive | MCP tools | Notes |
 | --- | --- | --- |
 | Protected Fetch | `scrape` | Default markdown; HTML / plaintext / PDF / screenshot options |
-| Extract | `extract` | Structured JSON (`extract=auto`, autoparse, css_extractor). `extract=auto` open beta (currently free; billing may apply later) |
-| Batch | `batch_create`, `batch_status`, `batch_results`, `batch_cancel` | Beta; may return `BATCH_ACCESS_DENIED` without access |
+| Extract | `extract` | Structured JSON (`extract=auto`, autoparse, css_extractor). `extract=auto` is currently free; billing may apply later |
+| Batch | `batch_create`, `batch_status`, `batch_results`, `batch_cancel` | Same credits as Fetch; a 403 maps to `BATCH_ACCESS_DENIED` |
 | Browser | `browser_*` (start with `browser_navigate`) | Escalation-only; same backend as Browser Sessions |
 
 ## Cost notes

package/dist/src/adapters/batch.js

@@ -1,9 +1,8 @@
 /**
  * Batch Jobs adapter.
  *
- * Status: `beta` — the Zenrows Batch API is in beta.
- * With beta access the cloud subcommands run for real (see `core/batch-api.ts`).
- * Without access the API returns 403 → BATCH_ACCESS_DENIED. This adapter owns
+ * Status: `available`. The cloud subcommands call the Batch API with an API key
+ * (see `core/batch-api.ts`); a 403 maps to BATCH_ACCESS_DENIED. This adapter owns
  * the local, no-network pieces: validating a JSONL job spec, estimating credit
  * cost, and mapping the validated spec to the Batch API request body.
  */

package/dist/src/adapters/extract.js

@@ -55,6 +55,18 @@ async function runExtractOnce(opts, config, policy, apiKey) {
         output: method === "markdown" ? "markdown" : method === "plaintext" ? "plaintext" : "html",
     };
     const outcome = await runFetch(fetchOpts, config, policy, apiKey);
+    if (outcome.result.noDataExtracted) {
+        if (opts.validate) {
+            throw new ToolkitError({
+                code: "EXTRACT_VALIDATION_FAILED",
+                message: "Extract found no data on this page.",
+                likely_cause: "Extract knows this kind of page, but none of the fields came back filled (HTTP 422 no_data_extracted). The request was not charged.",
+                next_action: "Check that the page rendered fully: try --manual --js-render with --wait-for <selector>. Protected sites may also need --premium-proxy.",
+                suggested_commands: [`zenrows extract ${opts.url} --manual --js-render --premium-proxy`],
+            });
+        }
+        return { ...outcome, method, empty: true, noDataExtracted: true };
+    }
     const { data, html, empty } = parseExtractBody(method, outcome.result.body, opts);
     return { ...outcome, method, data, html, empty };
 }
@@ -80,7 +92,7 @@ function parseExtractBody(method, body, opts) {
     }
     let data = parsed;
     let html;
-    // extract=auto beta shape: { parsed, html }. Prefer `parsed` for callers.
+    // extract=auto shape: { parsed, html }. Prefer `parsed` for callers.
     if (method === "extract" && parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const envelope = parsed;
         if ("parsed" in envelope) {

package/dist/src/cli/commands/batch.js

@@ -1,10 +1,10 @@
 /**
- * `zenrows batch` — Batch API (status: beta).
+ * `zenrows batch`: Batch API (status: available).
  *
  * Local (no key, always works): `estimate`/`create --dry-run`-style spec
- * validation + credit estimate. Cloud (needs a key + Batch beta access):
- * `create`, `status`, `results`, `cancel`, `wait`, `retry-failed`. Without beta
- * access the API returns 403 → BATCH_ACCESS_DENIED.
+ * validation + credit estimate. Cloud (needs a key):
+ * `create`, `status`, `results`, `cancel`, `wait`, `retry-failed`. A 403 maps to
+ * BATCH_ACCESS_DENIED.
  */
 import { statSync } from "node:fs";
 import { join } from "node:path";
@@ -22,12 +22,12 @@ import { ToolkitError, isKeyCapReached, keyCapReached } from "../../core/errors.
 import { printError, writeOut } from "../output.js";
 export const batch = {
     name: "batch",
-    summary: "Run JSONL batch jobs on Zenrows Batch (beta).",
+    summary: "Run JSONL batch jobs on Zenrows Batch.",
     usage: "zenrows batch <estimate|create <file.jsonl>|status <id>|results <id>|cancel <id>|wait <id>|retry-failed <id>>",
     help: [
         "Local (no key):",
         "  estimate <file.jsonl> [--manual] validate the spec + estimate credits (upper bound)",
-        "Cloud (needs a key + Batch beta access):",
+        "Cloud (needs a key):",
         "  create <file.jsonl> [flags]      validate, then submit the job",
         "    (default)                      Adaptive Stealth Mode (mode=auto) on every task that",
         "                                   doesn't force js_render / premium_proxy itself",

package/dist/src/cli/commands/extract.js

@@ -1,7 +1,7 @@
 /**
  * `zenrows extract <url> [flags]` → Extract (structured extraction on `/v1/`).
  *
- * Default: `extract=auto` (site-tailored Extract, open beta). If the domain is
+ * Default: `extract=auto` (site-tailored Extract). If the domain is
  * not enabled or prepared (AUTH010 / REQS007), falls back once to Autoparse. Opt into Autoparse
  * directly with `--autoparse`. Other methods: `--css`, `--outputs`, `--output`.
  */
@@ -23,7 +23,7 @@ export const extract = {
     usage: "zenrows extract <url> [--autoparse | --css <json> | --outputs <filters> | --output md|text] [flags]",
     help: [
         "Methods:",
-        "  (default)              extract=auto — site-tailored Extract (open beta); falls back to Autoparse if the domain is not enabled or prepared",
+        "  (default)              extract=auto: site-tailored Extract; falls back to Autoparse if the domain is not enabled or prepared",
         "  --autoparse            general-purpose Autoparse (any domain, no Extract fallback)",
         "  --css <json>           CSS selector map, e.g. '{\"title\":\"h1\",\"price\":\".price\"}'",
         "  --outputs <list>       built-in output filters → JSON: emails, phone_numbers, headings,",
@@ -148,7 +148,10 @@ export const extract = {
             log.success(`Extracted via ${via} · ${outcome.result.body.length} bytes · ${formatRequestCost(outcome.result.costUsd, outcome.result.costCredits)} · run ${runId}`);
             if (runDir)
                 log.dim(`  artifact: ${runDir}`);
-            if (outcome.empty) {
+            if (outcome.noDataExtracted) {
+                log.warn("Extract found no data on this page (HTTP 422 no_data_extracted, not charged). Check that the page rendered fully: try --manual --js-render with --wait-for <selector>. Protected sites may also need --premium-proxy.");
+            }
+            else if (outcome.empty) {
                 log.warn("No structured data extracted — the page may render via JavaScript, or this layout isn't auto-extractable. Try --manual --js-render, or --css with explicit selectors.");
             }
             if (ctx.json || values.json) {
@@ -158,6 +161,7 @@ export const extract = {
                     method: outcome.method,
                     fellBackToAutoparse: outcome.fellBackToAutoparse ?? false,
                     empty: outcome.empty ?? false,
+                    noDataExtracted: outcome.noDataExtracted ?? false,
                     httpStatus: outcome.result.status,
                     data: outcome.data ?? null,
                     bytes: outcome.result.body.length,

package/dist/src/core/batch-api.js

@@ -111,8 +111,8 @@ function problemToError(status, body, method, path) {
         return new ToolkitError({
             code: "BATCH_ACCESS_DENIED",
             message: "The Batch API rejected this request (access denied).",
-            likely_cause: `${cause}. The Batch API is in beta and this account does not have beta access.`,
-            next_action: "Request Batch API beta access from Zenrows. Meanwhile validate/estimate specs locally and fan out with `zenrows fetch` per URL.",
+            likely_cause: `${cause}. Batch is not enabled for this account or API key.`,
+            next_action: "Check that your Zenrows API key is active, and contact Zenrows support if the 403 persists. Meanwhile validate/estimate specs locally and fan out with `zenrows fetch` per URL.",
             suggested_commands: ["zenrows batch estimate jobs.jsonl"],
         });
     }

package/dist/src/core/capabilities.js

@@ -24,8 +24,8 @@ export function getCapability(key) {
 const USABLE = new Set([
     "available",
     "available-but-needs-confirmation",
-    // Open beta: any key can call; product-specific limits (e.g. Extract domain
-    // coverage, Batch 403) are handled by the adapters / API errors, not here.
+    // Beta: any key can call; product-specific limits are handled by the
+    // adapters / API errors, not here.
     "beta",
 ]);
 export function isUsable(key) {

package/dist/src/core/config.js

@@ -14,7 +14,7 @@ export const CONFIG_VERSION = "0.1.0";
  * entrypoint) so core modules — telemetry, signup provenance — can read it
  * without an import cycle. `VERSION` in `cli/index.ts` re-exports this.
  */
-export const CLI_VERSION = "1.5.0";
+export const CLI_VERSION = "1.5.1";
 /** The User-Agent on every request to a Zenrows API. The gateway reads the version from it. */
 export const CLI_USER_AGENT = `zenrows-cli/${CLI_VERSION}`;
 /** Env var to override the Fetch and Extract API base (local/staging testing). */

package/dist/src/core/http.js

@@ -106,10 +106,29 @@ export async function scrape(apiBase, apiKey, params, opts = {}) {
             code: "EXTRACT_DOMAIN_NOT_ENABLED",
             message: "Extract has not been prepared for this domain yet.",
             likely_cause: zrErrorDetail(body) ?? "This domain is not prepared for Extract.",
-            next_action: "Retry with --autoparse for general-purpose extraction on any site.",
+            next_action: "Retry with --autoparse for general-purpose extraction on any site, or get the domain prepared for Extract (POST /v1/extract/prepared-domains).",
             suggested_commands: [`zenrows extract ${params.url} --autoparse`],
         });
     }
+    // 422 no_data_extracted on an Extract request: the page was processed and had
+    // nothing to extract. It is an answer, not a failure to reach the target, so
+    // return it for the extract adapter to report as an empty result instead of
+    // advising escalation (which would repeat a slow, deterministic request).
+    if (res.status === 422 && params.extract !== undefined && zrErrorCode(body) === "NO_DATA_EXTRACTED") {
+        return { ...result, noDataExtracted: true };
+    }
+    // 422 blocked_document on an Extract request: the fetched page was a bot wall,
+    // an error page or an empty shell, so Extract had nothing real to read. Not
+    // charged. The fix is a stronger fetch of the same URL, not another extractor.
+    if (res.status === 422 && params.extract !== undefined && zrErrorCode(body) === "BLOCKED_DOCUMENT") {
+        throw new ToolkitError({
+            code: "EXTRACT_FAILED",
+            message: "Extract could not read this page: the site answered with a block or error page (HTTP 422 blocked_document, not charged).",
+            likely_cause: zrErrorDetail(body) ?? "The fetched page was a bot challenge, an error page or a page that had not finished loading.",
+            next_action: "Retry with a stronger fetch: --manual --js-render --premium-proxy. Check the URL if the site may be returning an error page.",
+            suggested_commands: [`zenrows extract ${params.url} --manual --js-render --premium-proxy`],
+        });
+    }
     if (res.status === 401 || res.status === 403) {
         // Distinguish Zenrows auth errors from target-site 403s. Zenrows auth
         // failures surface AUTH00x codes in the body.
@@ -143,15 +162,15 @@ export async function scrape(apiBase, apiKey, params, opts = {}) {
         }
     }
     if (res.status === 402 && isZenrowsErrorEnvelope(body)) {
-        // AUTH010 on extract=auto means the target domain is not in the Extract
-        // beta — distinct from credit exhaustion (AUTH004). Let the extract
+        // AUTH010 on extract=auto means the target domain is not enabled for
+        // Extract, distinct from credit exhaustion (AUTH004). Let the extract
         // adapter fall back to autoparse.
         if (params.extract !== undefined && zrErrorCode(body) === "AUTH010") {
             throw new ToolkitError({
                 code: "EXTRACT_DOMAIN_NOT_ENABLED",
                 message: "Extract is not enabled for this domain yet.",
-                likely_cause: zrErrorDetail(body) ?? "This domain is not part of the Extract open beta.",
-                next_action: "Retry with --autoparse for general-purpose extraction on any site, or contact Zenrows support to enable this domain for Extract.",
+                likely_cause: zrErrorDetail(body) ?? "This domain is not enabled for Extract.",
+                next_action: "Retry with --autoparse for general-purpose extraction on any site, or get the domain prepared for Extract (POST /v1/extract/prepared-domains).",
                 suggested_commands: [`zenrows extract ${params.url} --autoparse`],
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenrows/cli",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Open-source CLI, MCP, skills, templates, workflows, recipes, and evals layer for giving AI agents reliable access to protected web data through Zenrows cloud infrastructure.",
   "type": "module",
   "license": "MIT",

package/recipes/batch-estimate/RECIPE.md

@@ -26,8 +26,8 @@ Swap `jobs.jsonl` for your own spec. Per-line keys (`js_render`,
 `premium_proxy`, `proxy_country`, `mode`, `autoparse`, `external_id`) tune each
 URL; cost multipliers are basic 1x / JS 5x / proxy 10x / both 25x.
 
-Once the spec is clean, submit it with beta access:
+Once the spec is clean, submit it:
 ```
 zenrows batch create jobs.jsonl --wait
 ```
-See [[batch-jobs]] for the full cloud flow (beta).
+See [[batch-jobs]] for the full cloud flow.

package/registry/capabilities.json

@@ -13,20 +13,20 @@
     "extract": {
       "key": "extract",
       "label": "Extract (extract=auto / Autoparse / CSS / Markdown)",
-      "status": "beta",
+      "status": "available",
       "command": "zenrows extract",
       "backend": "Extract — GET https://api.zenrows.com/v1/ (extract=auto, autoparse, css_extractor, outputs, response_type)",
       "requiresAuth": true,
-      "notes": "Open beta. Default is extract=auto (domain-gated); CLI falls back to autoparse on AUTH010. Autoparse / CSS / outputs / markdown work on any domain."
+      "notes": "Default is extract=auto, which works on any prepared domain with any key; CLI falls back to autoparse on REQS007 (domain not prepared yet) or AUTH010. Autoparse / CSS / outputs / markdown work on any domain."
     },
     "batch": {
       "key": "batch",
-      "label": "Batch (beta)",
-      "status": "beta",
+      "label": "Batch",
+      "status": "available",
       "command": "zenrows batch",
       "backend": "Batch — https://async.api.zenrows.com/v1 (X-API-Key header; separate host from the Fetch/Extract /v1/)",
       "requiresAuth": true,
-      "notes": "Open beta. Cloud subcommands (create/status/results/cancel/wait/retry-failed) call the Batch API; `zenrows batch estimate` works locally with no API key."
+      "notes": "Cloud subcommands (create/status/results/cancel/wait/retry-failed) call the Batch API with your API key; `zenrows batch estimate` works locally with no API key."
     },
     "crawl": {
       "key": "crawl",

package/registry/skills.json

@@ -26,7 +26,7 @@
       "name": "extract",
       "type": "skill",
       "description": "Turn protected pages into structured data with Autoparse / CSS / Markdown.",
-      "status": "beta",
+      "status": "available",
       "requires_backend_capabilities": ["extract"],
       "requires_auth": true,
       "version": "0.1.0",
@@ -36,8 +36,8 @@
     {
       "name": "batch-jobs",
       "type": "skill",
-      "description": "Scale protected fetch/extract over many URLs with Batch (beta): submit/track/collect jobs with beta access; validate + estimate specs locally with no key.",
-      "status": "beta",
+      "description": "Scale protected fetch/extract over many URLs with Batch: submit/track/collect jobs with an API key; validate + estimate specs locally with no key.",
+      "status": "available",
       "requires_backend_capabilities": ["batch"],
       "requires_auth": true,
       "version": "0.1.0",

package/registry/templates.json

@@ -25,8 +25,8 @@
     {
       "name": "batch-jsonl-pipeline",
       "type": "template",
-      "description": "JSONL job-spec scaffold for high-scale workloads on Batch: submit/track/collect with beta access, validate + estimate locally with no key (beta).",
-      "status": "beta",
+      "description": "JSONL job-spec scaffold for high-scale workloads on Batch: submit/track/collect with an API key, validate + estimate locally with no key.",
+      "status": "available",
       "requires_backend_capabilities": [],
       "requires_auth": false,
       "version": "0.1.0",

package/skills/batch-jobs/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: batch-jobs
-description: Scale protected fetch/extract over many URLs via Batch (beta). Cloud create/status/results/cancel/wait/retry-failed work with beta access; estimate/validate run locally with no key.
+description: Scale protected fetch/extract over many URLs via Batch. Cloud create/status/results/cancel/wait/retry-failed work with an API key; estimate/validate run locally with no key.
 version: 0.1.0
 requires_backend_capabilities: [batch]
 ---
@@ -11,11 +11,10 @@ Process large workloads reliably and asynchronously. Batch is where Zenrows'
 high-scale anti-bot advantage becomes obvious — Zenrows wins when the workflow
 runs over thousands, millions, or recurring sets of URLs.
 
-> Status: **beta**. The Zenrows **Batch** is a real
-> product in beta and runs on a separate host
-> (`async.api.zenrows.com/v1`). The cloud subcommands work once your account has
-> beta access; without it the API returns 403 → `BATCH_ACCESS_DENIED`. The
-> toolkit never fakes a cloud run.
+> Zenrows **Batch** runs on a separate host (`async.api.zenrows.com/v1`) and
+> spends the same credits as Fetch. The cloud subcommands work with any active
+> API key; a 403 maps to `BATCH_ACCESS_DENIED`. The toolkit never fakes a
+> cloud run.
 
 ## Local (no key, always works)
 ```
@@ -40,7 +39,7 @@ correctly. The result carries two keys: `html` (the
 raw page) and `parsed` (the structured data). Validate on a single URL with
 `zenrows extract <url>` before running the full batch.
 
-## Cloud (needs a key + beta access)
+## Cloud (needs a key)
 ```
 zenrows batch create jobs.jsonl [--proxy-country cc] [--wait]
 zenrows batch create jobs.jsonl --manual [--js-render] [--premium-proxy]

package/skills/extract/SKILL.md

@@ -12,7 +12,7 @@ access + extraction**, not generic LLM parsing.
 
 ## Methods
 ```
-zenrows extract <url>                              # extract=auto (default); falls back to Autoparse if domain not enabled
+zenrows extract <url>                              # extract=auto (default); falls back to Autoparse if the domain is not prepared yet
 zenrows extract <url> --autoparse                  # general-purpose Autoparse (any domain)
 zenrows extract <url> --css '{"title":"h1","price":".price"}'   # selector map
 zenrows extract <url> --outputs emails,links       # built-in output filters → JSON
@@ -21,8 +21,8 @@ zenrows extract <url> --validate                   # fail if not valid JSON
 ```
 
 ## When to use which
-- **Extract** (`extract=auto`, default): richest fields on domains enabled for the open beta.
-- **Autoparse**: any website; also the automatic fallback when Extract is not enabled for the domain.
+- **Extract** (`extract=auto`, default): richest fields; works on any domain Zenrows has prepared.
+- **Autoparse**: any website; also the automatic fallback when the domain is not prepared for Extract yet.
 - **CSS**: you know the exact fields/selectors and want determinism.
 - **Markdown/plaintext**: feed clean content to an LLM yourself.
 

package/skills/zenrows/SKILL.md

@@ -72,8 +72,8 @@ Run `zenrows status` for the live capability matrix. As of this toolkit:
 | Primitive | Command | Status |
 | --- | --- | --- |
 | Protected Fetch | `zenrows fetch` | available (`GET /v1/`) |
-| Extract (extract=auto / Autoparse/CSS/Markdown) | `zenrows extract` | beta (same `/v1/`; extract=auto falls back to autoparse) |
-| Batch | `zenrows batch` | beta — runs cloud jobs (create/status/results); cheapest path at scale. Estimate specs locally with no key |
+| Extract (extract=auto / Autoparse/CSS/Markdown) | `zenrows extract` | available (same `/v1/`; extract=auto falls back to autoparse) |
+| Batch | `zenrows batch` | available: runs cloud jobs (create/status/results); cheapest path at scale. Estimate specs locally with no key |
 | Crawl | `zenrows crawl` | new — collect the URLs behind one start page, optionally with each page's HTML |
 | Browser | `zenrows browser` | available (Browser Sessions REST API / MCP) |
 | MCP | `zenrows mcp` | available (remote + local server) |

package/templates/batch-jsonl-pipeline/README.md

@@ -16,10 +16,10 @@ results carry `html` and `parsed` keys.
 zenrows batch estimate jobs.example.jsonl    # validate the spec + estimate credits
 ```
 
-## Cloud (needs a key + Batch beta access)
+## Cloud (needs a key)
 
-Batch is in **beta**. With beta access the
-cloud subcommands run for real; without it the API returns `BATCH_ACCESS_DENIED`.
+The cloud subcommands run with any active API key and spend the same credits
+as Fetch.
 
 ```bash
 zenrows batch create jobs.example.jsonl --wait          # submit + wait for the run to finish
@@ -33,5 +33,5 @@ Tasks use Adaptive Stealth Mode (`mode=auto`) by default. Job-level scrape
 options come from flags (`--js-render`, `--premium-proxy`, `--proxy-country`,
 `--output`, or `--manual` to turn Adaptive Stealth Mode off); per-line keys
 override them for that URL.
-Without beta access yet, validate/estimate locally or fan out with
-`zenrows fetch` per URL on a small sample first.
+Validate/estimate locally, or try `zenrows fetch` per URL on a small sample
+first.

package/templates/extract-pricing-pages/README.md

@@ -13,5 +13,5 @@ zenrows extract https://www.scrapingcourse.com/ecommerce/ --autoparse
 zenrows extract <product-url> --css '{"title":"h1","price":".price"}' --validate
 ```
 
-Requires `extract` (open beta). Start on one page, confirm the fields, then
+Requires `extract`. Start on one page, confirm the fields, then
 fan out `zenrows extract` across the rest of your URLs.

package/workflows/competitor-intelligence/WORKFLOW.md

@@ -20,7 +20,7 @@ simple per-URL loop).
    ```
    zenrows fetch https://competitor.example/products
    ```
-2. **Validate extraction** on one page (extract is beta; extract=auto falls back to autoparse).
+2. **Validate extraction** on one page (extract=auto falls back to autoparse on a domain not prepared yet).
    ```
    zenrows extract https://competitor.example/p/123 --validate
    ```