> ## Documentation Index
> Fetch the complete documentation index at: https://deepline.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Context.dev: Contextdev Preview Webdb

> Preview extraction (dry run). Includes SDK V2 and CLI requests, input constraints, response fields, and Deepline credit cost.

Preview extraction (dry run).

<Info>
  Tool ID: `contextdev_preview_webdb`
</Info>

## Run this action

Use the TypeScript SDK for a single call. Put `ctx.tools.execute(...)` inside a Play when the call should be durable, scheduled, or run across a CSV.

```ts theme={null}
import { Deepline } from 'deepline';

const deepline = await Deepline.connect();
const result = await deepline.tools.execute(
  'contextdev_preview_webdb',
  {
    "urls": [
      "https://example.com/resource"
    ],
    "schema": {}
  },
);

console.log(result.toolResponse.raw);
```

### CLI

```bash theme={null}
deepline tools execute contextdev_preview_webdb --input '{
  "urls": [
    "https://example.com/resource"
  ],
  "schema": {}
}' --json
```

## Example response

The static output schema is not detailed enough to generate a reliable example. Use `deepline tools get contextdev_preview_webdb --json` for the complete live contract.

## Input reference

Tests extraction without creating a collection.

| Name                  | Type     | Required | Default | Details                                                                                                |
| --------------------- | -------- | -------- | ------- | ------------------------------------------------------------------------------------------------------ |
| `payload.urls`        | `array`  | Yes      | —       | URLs to test. Maximum 5. Minimum items: 1. Maximum items: 5.                                           |
| `payload.schema`      | `object` | Yes      | —       | JSON Schema for the fields extracted into each row. Zod users can pass the output of z.toJSONSchema(). |
| `payload.eligibility` | `object` | No       | —       | Rules that decide whether a page becomes a row.                                                        |
| `payload.tags`        | `array`  | No       | —       | Optional tags for tracking usage. Up to 20 tags, each 1 to 50 characters. Maximum items: 20.           |

<details>
  <summary>Show raw input schema</summary>

  ### Input JSON Schema

  ```json theme={null}
  {
    "type": "object",
    "description": "Tests extraction without creating a collection.",
    "properties": {
      "urls": {
        "type": "array",
        "description": "URLs to test. Maximum 5.",
        "minItems": 1,
        "maxItems": 5,
        "items": {
          "type": "string",
          "format": "uri"
        }
      },
      "schema": {
        "type": "object",
        "description": "JSON Schema for the fields extracted into each row. Zod users can pass the output of z.toJSONSchema().",
        "additionalProperties": true
      },
      "eligibility": {
        "type": "object",
        "description": "Rules that decide whether a page becomes a row.",
        "properties": {
          "prefilter": {
            "type": "object",
            "description": "Fast URL and text checks.",
            "properties": {
              "url_match": {
                "type": "array",
                "description": "URL patterns a page must match. Supports exact URLs, `*`, `**`, and `:name` path values.",
                "maxItems": 50,
                "items": {
                  "type": "string"
                }
              },
              "must_contain_any": {
                "type": "array",
                "description": "Text where at least one value must appear.",
                "maxItems": 50,
                "items": {
                  "type": "string"
                }
              },
              "must_not_contain": {
                "type": "array",
                "description": "Text values that must not appear.",
                "maxItems": 50,
                "items": {
                  "type": "string"
                }
              }
            },
            "additionalProperties": false
          },
          "semantic": {
            "type": "object",
            "description": "AI check for whether a page should become a row.",
            "properties": {
              "condition": {
                "type": "string",
                "description": "Plain-language rule a page must satisfy.",
                "minLength": 1,
                "maxLength": 4000
              },
              "min_score": {
                "type": "number",
                "description": "Minimum matching score from 0 to 1. Defaults to 0.7.",
                "minimum": 0,
                "maximum": 1
              }
            },
            "required": [
              "condition"
            ],
            "additionalProperties": false
          }
        },
        "additionalProperties": false
      },
      "tags": {
        "type": "array",
        "description": "Optional tags for tracking usage. Up to 20 tags, each 1 to 50 characters.",
        "maxItems": 20,
        "items": {
          "type": "string",
          "minLength": 1,
          "maxLength": 50
        }
      }
    },
    "required": [
      "urls",
      "schema"
    ],
    "additionalProperties": false
  }
  ```
</details>

## Output reference

| Name                                              | Type             | Required | Default | Details |
| ------------------------------------------------- | ---------------- | -------- | ------- | ------- |
| `result.data`                                     | `object`         | Yes      | —       | —       |
| `result.data.results`                             | `array`          | Yes      | —       | —       |
| `result.data.results[].url`                       | `string`         | Yes      | —       | —       |
| `result.data.results[].end_url`                   | `string \| null` | Yes      | —       | —       |
| `result.data.results[].eligibility`               | `object \| null` | Yes      | —       | —       |
| `result.data.results[].eligibility.eligible`      | `boolean`        | Yes      | —       | —       |
| `result.data.results[].eligibility.score`         | `number \| null` | Yes      | —       | —       |
| `result.data.results[].eligibility.reason`        | `string`         | Yes      | —       | —       |
| `result.data.results[].row`                       | `object \| null` | Yes      | —       | —       |
| `result.data.results[].fields`                    | `object \| null` | Yes      | —       | —       |
| `result.data.results[].extraction`                | `object \| null` | Yes      | —       | —       |
| `result.data.results[].extraction.confidence`     | `number \| null` | Yes      | —       | —       |
| `result.data.results[].extraction.missing_fields` | `array`          | Yes      | —       | —       |
| `result.data.results[].error`                     | `string \| null` | Yes      | —       | —       |
| `result.data.key_metadata`                        | `object`         | No       | —       | —       |
| `result.meta`                                     | `object`         | No       | —       | —       |

<details>
  <summary>Show raw output schema</summary>

  ### Output JSON Schema

  ```json theme={null}
  {
    "type": "object",
    "properties": {
      "data": {
        "type": "object",
        "properties": {
          "results": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "url": {
                  "type": "string"
                },
                "end_url": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "eligibility": {
                  "type": [
                    "object",
                    "null"
                  ],
                  "properties": {
                    "eligible": {
                      "type": "boolean"
                    },
                    "score": {
                      "type": [
                        "number",
                        "null"
                      ]
                    },
                    "reason": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "eligible",
                    "score",
                    "reason"
                  ],
                  "additionalProperties": false
                },
                "row": {
                  "type": [
                    "object",
                    "null"
                  ],
                  "additionalProperties": {}
                },
                "fields": {
                  "type": [
                    "object",
                    "null"
                  ],
                  "additionalProperties": {
                    "type": "object",
                    "properties": {
                      "status": {
                        "type": "string",
                        "enum": [
                          "extracted",
                          "missing",
                          "invalid",
                          "low_confidence"
                        ]
                      },
                      "confidence": {
                        "type": [
                          "number",
                          "null"
                        ]
                      }
                    },
                    "required": [
                      "status",
                      "confidence"
                    ],
                    "additionalProperties": false
                  }
                },
                "extraction": {
                  "type": [
                    "object",
                    "null"
                  ],
                  "properties": {
                    "confidence": {
                      "type": [
                        "number",
                        "null"
                      ]
                    },
                    "missing_fields": {
                      "type": "array",
                      "items": {
                        "type": "string"
                      }
                    }
                  },
                  "required": [
                    "confidence",
                    "missing_fields"
                  ],
                  "additionalProperties": false
                },
                "error": {
                  "type": [
                    "string",
                    "null"
                  ]
                }
              },
              "required": [
                "url",
                "end_url",
                "eligibility",
                "row",
                "fields",
                "extraction",
                "error"
              ],
              "additionalProperties": false
            }
          },
          "key_metadata": {
            "type": "object",
            "properties": {},
            "required": [],
            "additionalProperties": false
          }
        },
        "required": [
          "results"
        ],
        "additionalProperties": false
      },
      "meta": {
        "type": "object",
        "additionalProperties": true
      }
    },
    "required": [
      "data"
    ],
    "additionalProperties": false
  }
  ```
</details>

## Deepline cost

* Pricing model: `fixed` (per call).
* Estimated Deepline credits: `0` per pricing unit.
* Provider-native pricing may still exist outside Deepline credit billing.

## Related documentation

* [Context.dev provider guide](/docs/providers/contextdev/guide)
* [SDK V2 quickstart](/docs/sdk-v2/quickstart)
* [SDK reference](/docs/sdk-v2/sdk-reference)
* [Run tools across a CSV](/docs/sdk-v2/batch-csv)
