# Imperva Credential Verifier — reese84 Unlock & Schema (`lentic_clockss/imperva-schema`) Actor

Query Imperva credential-layer descriptors — per-site slots, credential specs and a budgeted usage ledger — and verify that an issued reese84 cookie unlocks a protected page. One dataset row per operation. Credential values are never returned, only their length.

- **URL**: https://apify.com/lentic_clockss/imperva-schema.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Developer tools, Automation, MCP servers
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Read Imperva / Incapsula credential-layer descriptors — per-site slots, credential specs and a budgeted usage ledger — and verify that an issued `reese84` session cookie (with optional `visid_incap_*`, `incap_ses_*` and `utmvc` marker cookies) unlocks a protected page. One dataset row per operation.**

- Query registered slots and credential specs, and read the per-epoch usage ledger and remaining budget.
- Verify an issued `reese84` cookie: the `unlock` operation replays it once (alongside any `visid_incap_*`, `incap_ses_*` or `utmvc` marker cookies) against your page URL and reports whether it opened the page.
- Credential values are never returned — only `value_len`, so secrets stay out of the dataset.
- Pay only for the rows you receive: $0.55 per 1,000 rows on the Free plan plus a small start fee.

### What does Imperva Credential Verifier do?

Imperva Credential Verifier is a metadata registry plus a single verification probe for sites behind Imperva / Incapsula edge protection. It does not solve the challenge and it does not issue cookies itself — you supply an already-issued `reese84` credential (and optional `visid_incap_*` / `incap_ses_*` marker cookies), and the `unlock` operation checks that it opens the page.

- **Read the registry**: `get_slot`, `list_slots`, `list_credentials`, `list_ledger` and `budget_remaining` return the stored descriptors — slots, credential specs, ledger entries and remaining budget.
- **Verify a credential**: `unlock` presents your `reese84` value once against the target URL and reports `unlocked` plus the replayed page status, or diagnostics when it was turned away.

One operation produces one dataset row.

### What data can you extract from Imperva Credential Verifier?

| Field | Description | Example |
| --- | --- | --- |
| `op` | The operation that produced the row | `unlock` |
| `status` | Result status of the operation | `ok` |
| `slot` | Per-site slot descriptor (on `get_slot`) | `{"host":"…","site_id":"…"}` |
| `slots` | Matching slot descriptors (on `list_slots`) | `[…]` |
| `credentials` | Matching credential specs (on `list_credentials`) | `[…]` |
| `ledger` | Usage ledger entries (on `list_ledger`) | `[…]` |
| `budget` | Remaining budget for the key (`budget_remaining`, `unlock`) | `{"cap":14,"used":3,"remaining":11}` |
| `unlocked` | `true` when the credential opened the page (on `unlock`) | `true` |
| `credential` | Credential descriptor on `unlock` — `value_len` only, never the value | `{"kind":"imperva_edge_reese84","value_len":1234}` |
| `row` | The replayed page on a successful `unlock` | `{"statusCode":200,"unlocked":true}` |
| `diagnostics` | `statusCode`, `failureClass` and `error` when an `unlock` was turned away | `{"statusCode":403,"failureClass":"denied_edge"}` |
| `scrapedAt` | When the row was written | `2026-10-28T12:00:00Z` |

### How to use Imperva Credential Verifier

1. Open [Imperva Credential Verifier](https://apify.com/lentic_clockss/imperva-schema) in Apify Console (a free Apify account is enough to try it).
2. Pick an `op`, for example `list_slots`.
3. Leave `maxResults` small, for example 3, for your first run.
4. Click **Start** and wait for the run to finish.
5. Read the operation's result from the dataset row.

An empty input runs the sample op, limited to at most 10 rows, so you can see the output format before spending anything.

#### Read the registry

Set `op` to one of the read operations and pass any filters through `args`. For example `{"op":"list_slots","args":{"host":"example.com"}}` returns the slots for that host, and `{"op":"budget_remaining","args":{...}}` returns the remaining budget for a key.

#### Verify a credential

Set `op` to `unlock` and give it the page `url` plus your issued `reese84` value in `credential_value` (and any marker cookies in `cookie_header`). These fields are secret and are never logged or returned — the result carries only `value_len`.

```json
{
  "op": "unlock",
  "url": "https://example.com/page",
  "credential_value": "<your reese84 value>",
  "cookie_header": "visid_incap=…; incap_ses_…=…",
  "maxResults": 1
}
```

### What to fill in

| Field | What to enter | Default |
| --- | --- | --- |
| `op` | The operation to run | required |
| `args` | Operation arguments as an object | `{}` |
| `maxResults` | Most rows to deliver and charge for this run | `3` |
| `returnRaw` | Push the raw result object as one row | `false` |
| `url` | Target page URL (for `unlock`) | — |
| `credential_value` | The `reese84` value to verify (for `unlock`, secret) | — |
| `cookie_header` | Marker cookies to send with it (for `unlock`, secret) | — |
| `request_type` | Request type for `unlock` | `navigation` |

- `maxResults` is the most rows for the run, one per operation (maximum 70). A single `unlock` produces one row.
- Unknown fields are ignored; an `op` outside the list or a missing required field stops the run before any row is charged.
- The `INPUT_ECHO` record in the run's key-value store shows the op and effective row cap the run used.

### Output example

A successful `unlock`:

```json
{
  "status": "ok",
  "unlocked": true,
  "credential": {
    "kind": "imperva_edge_reese84",
    "host": "example.com",
    "site_id": "123456",
    "unlocked": true,
    "value_len": 1234,
    "issuedAt": "2026-10-28T12:00:00Z"
  },
  "row": {
    "url": "https://example.com/page",
    "statusCode": 200,
    "contentType": "text/html; charset=utf-8",
    "bodyLen": 54321,
    "unlocked": true,
    "scrapedAt": "2026-10-28T12:00:00Z"
  },
  "budget": {"cap": 14, "used": 3, "remaining": 11, "epoch": "2026-10-28"}
}
```

A `list_slots` row carries `{"slots": […]}`; a `budget_remaining` row carries `{"budget": {…}}`. Export the dataset as JSON, CSV, Excel, XML, RSS or an HTML table.

### Why use this Imperva Credential verifier?

- **Pay per row.** You pay for rows written to the dataset, not for operations tried.
- **Secrets stay secret.** `credential_value` and `cookie_header` are never stored or returned — the result carries only `value_len`.
- **Clear errors.** A run that fails carries a reason instead of a silent empty result.
- **Bounded verification.** `unlock` runs one replay under a per-epoch cap, so it never loops against the target.
- **No setup.** You do not need your own fleet for the registry reads; `unlock` takes the credential you already hold.

### How much does it cost to use Imperva Credential Verifier?

The Actor uses pay-per-event pricing: a $0.005 start fee per run and a price per row delivered. Platform usage is included in these prices.

| Apify plan | Price per row | Price per 1,000 rows |
| --- | --- | --- |
| Free | $0.00055 | $0.55 |
| Starter | $0.00055 | $0.55 |
| Scale | $0.00055 | $0.55 |
| Business | $0.00055 | $0.55 |
| Platinum | $0.00055 | $0.55 |
| Diamond | $0.00055 | $0.55 |

- `maxResults` applies to the whole run, one row per operation. Default `3`; the maximum is `70`.
- Runs on the free Apify plan stop at 200 rows, and the free plan allows a limited number of runs of this Actor.
- The run never costs more than the **Maximum cost per run** you set in the run options (`maxTotalChargeUsd` in the API).
- The Apify Free plan includes **$5.00** in monthly usage credit (about **9,090 rows** at `$0.00055` per row across Free-plan runs capped at 200 rows per run).

Example: 3 operations → 3 rows → `3 × $0.00055 + $0.005 = $0.00665` on the Free plan.

### Use with AI agents and the API

#### Apify MCP server (Claude, ChatGPT, Cursor, VS Code)

Add this Actor as a tool in any MCP client that supports remote servers:

```
https://mcp.apify.com?tools=lentic_clockss/imperva-schema
```

Sign in with Apify when the client asks (OAuth), or send the header `Authorization: Bearer <YOUR_APIFY_TOKEN>`. The tool starts a run and returns the run and dataset IDs; the agent then reads the rows with `get-dataset-items`. Clients without remote MCP support can run `npx @apify/actors-mcp-server --tools lentic_clockss/imperva-schema` with the `APIFY_TOKEN` environment variable.

Example prompt: "List the Imperva credential slots for example.com" or "Verify this reese84 cookie unlocks https://example.com/page."

- **Agent execution note:** Set `maxResults` between `5` and `20` on exploratory tool calls to keep responses compact, and read `RUN_SUMMARY` and `INPUT_ECHO` from the default key-value store to inspect normalized inputs and delivered row counts.

#### Apify API

```python
import requests
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("lentic_clockss/imperva-schema").call(
    run_input={"op": "list_slots", "maxResults": 3}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Or over HTTP: `POST https://api.apify.com/v2/acts/lentic_clockss~imperva-schema/runs` with the input as the JSON body and your token in the `Authorization: Bearer` header, then `GET https://api.apify.com/v2/datasets/<datasetId>/items?format=json`.

#### Integrations

Connect the results to Google Sheets, Make, Zapier, n8n, Slack, Airtable or your own webhook from the **Integrations** tab of the Actor, or schedule regular runs with Apify Schedules.

### FAQ

#### Is the credential value returned?

No. `credential_value` and `cookie_header` are never stored or returned — the result carries only `value_len`, the descriptor's host/kind and the unlock verdict. Keep your credential values in your own secret store.

#### Does this Actor issue or solve the Imperva credential?

No. It does not issue credentials and it does not solve the challenge. `unlock` only verifies that a credential you already hold opens the page. Issue the `reese84` cookie yourself upstream, then verify it here.

#### What is `budget` / `budget_exhausted`?

`unlock` runs under a per-epoch verification cap (14 per epoch per key). When the epoch's shots are used, the operation returns `budget_exhausted` until the next epoch. Read the remaining budget first with `budget_remaining`.

#### What is `request_type` for `unlock`?

The kind of request the replay imitates — `navigation`, `xhr`, `fetch` or `probing`. Leave it at `navigation` for a normal page load.

#### Why did `unlock` report `unlocked: false`?

The credential did not open the page — it may be expired, bound to a different address or fingerprint, or turned away at the edge. `diagnostics` carries `statusCode` and `failureClass` (for example `denied_edge`).

#### Can I write to the registry?

Not through this Actor. It exposes the read operations and `unlock`; the write operations stay private so the shared registry cannot be changed from a public run.

#### Why did my run end as ABORTED?

A run ends ABORTED when the run timeout you set is shorter than the operation needed, or when the run's charge limit was reached. Rows already collected are still delivered and billed.

#### Is it legal to use this Actor?

You are responsible for complying with the target site's terms and with data-protection law. Verify credentials only for sites and sessions you are authorized to access.

### Limitations

- The read operations return stored descriptors only; they do not fetch the target site.
- `unlock` performs a single replay per call under a per-epoch cap; it is a verification probe, not a bulk fetcher.
- Credential values are never returned — plan to keep your own copy.
- A `reese84` cookie is bound to the address and fingerprint it was issued on; verifying it from a different connection can return `unlocked: false` even for a valid cookie.

### Related solvers and scrapers

More developer and data tools from the same publisher:

- [akamai Session solver](https://apify.com/lentic_clockss/akamai-solver)
- [AWS WAF Scraper](https://apify.com/lentic_clockss/aws-waf-solver)
- [Cloudflare solver](https://apify.com/lentic_clockss/cf-clearance-solver)
- [DataDome Scraper](https://apify.com/lentic_clockss/datadome-solver)
- [Stealth Web Scraper](https://apify.com/lentic_clockss/stealth-web-scraper)
- [Phone Number Validator](https://apify.com/lentic_clockss/phone-number-intelligence)
- [GitHub Scraper](https://apify.com/lentic_clockss/github-scraper)
- [Polymarket Scraper](https://apify.com/lentic_clockss/polymarket-scraper)

Browse all of our scrapers at [apify.com/lentic_clockss](https://apify.com/lentic_clockss).

### Support

Found a problem or need another field? Open an issue in the **Issues** tab of this Actor's page and include the run ID and the input you used.

# Actor input Schema

## `op` (type: `string`):

Registry read operation to run, or 'unlock' to verify a credential unlocks a page.

## `args` (type: `object`):

Free-form arguments passed to the operation.

## `maxResults` (type: `integer`):

Most rows to deliver and charge for this run.

## `returnRaw` (type: `boolean`):

Push the raw result object as a single row instead of its rows.

## `url` (type: `string`):

Target URL for unlock op.

## `credential_value` (type: `string`):

Credential for unlock op. Never logged or echoed in errors.

## `cookie_header` (type: `string`):

Cookie header for unlock op. Never logged or echoed in errors.

## `request_type` (type: `string`):

HTTP request type for unlock op.

## `site_id` (type: `string`):

Site identifier for unlock op.

## `egress_class` (type: `string`):

Outbound connection class for the verify call. Leave empty for the default.

## `issuer_env_id` (type: `string`):

Issuer environment ID for unlock op.

## `proxy_url` (type: `string`):

Proxy URL for unlock op.

## `timeout_s` (type: `number`):

Timeout in seconds for unlock op.

## `impersonate` (type: `string`):

Client profile for the verify call. Leave empty for the default.

## `host` (type: `string`):

Host header override for unlock op.

## Actor input object example

```json
{
  "op": "list_slots",
  "args": {},
  "maxResults": 3,
  "returnRaw": false,
  "request_type": "navigation"
}
```

# Actor output Schema

## `rows` (type: `string`):

One row per operation with the operation's result envelope.

## `runSummary` (type: `string`):

Run summary with row counts, the input as understood, and finish times.

## `inputEcho` (type: `string`):

Input values the run actually used after normalization.

## `errorSummary` (type: `string`):

Error information when the run fails.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "op": "list_slots",
    "args": {},
    "maxResults": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/imperva-schema").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "op": "list_slots",
    "args": {},
    "maxResults": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/imperva-schema").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "op": "list_slots",
  "args": {},
  "maxResults": 3
}' |
apify call lentic_clockss/imperva-schema --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lentic_clockss/imperva-schema"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/brOZFzi0hLFjI9dmZ/builds/GepQqL6D6nqBBvf6M/openapi.json