Imperva Credential Verifier — reese84 Unlock & Schema

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 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.

{
  "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:

{
  "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

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
• AWS WAF Scraper
• Cloudflare solver
• DataDome Scraper
• Stealth Web Scraper
• Phone Number Validator
• GitHub Scraper
• Polymarket Scraper

Browse all of our scrapers at 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.