# Wisconsin CCAP Case Search Scraper (`automation-lab/wisconsin-ccap-circuit-court-search`) Actor

Search Wisconsin CCAP public circuit court summaries by business, party name or case number. Export case IDs, captions, county, matched party, status, filing dates and source links; no docket, charge or birth-date data.

- **URL**: https://apify.com/automation-lab/wisconsin-ccap-circuit-court-search.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Wisconsin CCAP Case Search Scraper

Use Wisconsin CCAP case search to export public Wisconsin circuit court **summary records** for a business, a named party, or a known case number. Legal operations and research teams can compare scheduled snapshots of case identities, filing dates and status without collecting docket events, charges or birth dates.

This is an independent tool, not a Wisconsin Courts service. A matching name is not proof of identity, liability, guilt or conviction.

### What does it return?

One row per unique county/case identity, in source order. If several parties match a case, the first matched party is retained, not a full party list.

| Field | Meaning |
| --- | --- |
| caseId | Stable county number + case number |
| caseNo | Official case identifier |
| caption | Public summary caption |
| countyNo | Official county code, 1–72 |
| countyName | County name |
| matchedPartyName | First matched party, nullable |
| status | Source status, nullable |
| filingDate | Source filing date, nullable |
| sourceUrl | Official case link |
| scrapedAt | UTC observation timestamp |

The Actor never opens the case detail page. The link may require a CAPTCHA when you open it yourself. Birth dates, charges, docket events, documents, addresses and full party lists are excluded.

### Who is this for?

- Legal operations teams checking a known business name in a particular county.
- Researchers exporting public filing/status summaries for review.
- Teams that already know a county and case number and want a repeatable status snapshot.

It is not a background-check product and does not identify a person uniquely. It does not send alerts or compute changes for you.

### Why use this Actor?

The output is normalized into a stable case key and a small consistent table, rather than an HTML page. You can join successive exports on `caseId`, retain the observation timestamp and compare status changes in your own workflow. No court account, cookies supplied by you or proxy configuration is required.

### Getting started

1. Select one search mode below.
2. Prefer a specific business/party name and county to avoid oversized source searches.
3. Choose the maximum number of unique cases to save.
4. Run the Actor and inspect the Dataset tab.
5. Export JSON, CSV or Excel using Apify's dataset export controls.

Try this real tested input:

```json
{"businessName":"Wisconsin Restaurant Association","countyNo":13,"maxItems":5}
```

At testing this returned four public case summaries. Results and status can change over time.

### Input parameters

Choose **exactly one** of `businessName`, `lastName` or `caseNo`.

| Input | Behavior |
| --- | --- |
| businessName | WCCA native business-name search; trimmed, 2–120 characters |
| lastName | Native person surname search; trimmed, 2–120 characters |
| firstName | Optional native first-name filter, requires lastName, 2–120 characters |
| caseNo | Exact YYYYTTNNNNNN case number, trimmed and uppercased; requires countyNo |
| countyNo | Optional county for names, mandatory for case number; 13 means Dane |
| maxItems | Global unique-case output cap, 1–1000, default 100 |

Name matching is performed by WCCA, not a local exact-name matcher. Partial names may match. When first and last names are supplied, both are submitted together under the source's matching semantics. Results should be reviewed for relevance; name matching does not establish identity.

Business, person and case-number modes cannot be combined. Unsupported fields such as birth-date filters are rejected, not silently ignored. With no county on a name search, WCCA searches its supported counties; this does not guarantee complete statewide coverage.

### Case-number search

```json
{"caseNo":"2026UC000646","countyNo":13,"maxItems":5}
```

The county is essential because case numbers are not globally unique. This still returns only the search summary, not the case details.

### Output example

This illustrates the shape of a real business-summary result observed during testing:

```json
{
  "caseId": "13:2026UC000646",
  "caseNo": "2026UC000646",
  "caption": "Dept. of Workforce Development vs. WISCONSIN RESTAURANT ASSOCIATION INC",
  "countyNo": 13,
  "countyName": "Dane",
  "matchedPartyName": "WISCONSIN RESTAURANT ASSOCIATION INC",
  "status": "Filed Only",
  "filingDate": "2026-09-11",
  "sourceUrl": "https://wcca.wicourts.gov/caseDetail.html?caseNo=2026UC000646&countyNo=13",
  "scrapedAt": "2026-10-23T06:09:38.544Z"
}
```

### Limits and completeness

`maxItems` caps saved unique cases across the whole run after deduplication. It does not cap upstream search size: WCCA returns a summary list before the Actor applies the limit. There is no pagination or promise of exhaustive historical coverage. The first matching party is kept if the same case appears multiple times.

Broad statewide searches may be rejected by WCCA. Narrow the name or select a county. A rejected response, challenge or changed response schema fails the run rather than masquerading as a successful empty result. A recognized empty cases list is a valid successful no-match result.

Requests run sequentially. Transient DNS/network failures and HTTP 429/5xx have at most three attempts per request with bounded backoff. There is no browser, residential-proxy or CAPTCHA-solving fallback.

### How much does it cost to search Wisconsin circuit court summaries?

Pricing is pay per event: a **$0.005 start fee per run**, plus one **case summary** event per saved unique case. No per-case event is charged for duplicates or an empty result. A valid no-match search still has the start fee.

The applicable per-case prices depend on your Apify plan; the Pricing tab is authoritative. Illustrative BRONZE pricing is $0.00248 per case:

| Saved cases | BRONZE Actor event total |
| --- | --- |
| 1 | $0.007480 |
| 5 | $0.017400 |
| 100 | $0.253000 |

Totals describe Actor event charges, not third-party workflow costs. If a run fails after saving rows, those partial results and applicable charges may remain; do not treat a failed run as complete coverage.

### Integrations

Use an Apify Schedule for recurring snapshots. Export the dataset to a spreadsheet for review or send rows to your database through Apify integrations/API. Join snapshots on `caseId` and compare `status` or `filingDate`; keep `scrapedAt` so that an observation is never mistaken for a court update timestamp.

A Make or Zapier workflow can fetch the finished dataset and route changed rows to internal legal review. The Actor itself does not notify people, deduce outcomes or persist a monitoring baseline.

### API usage

Store your token securely; never include it in shared links.

```bash
curl -X POST -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"businessName":"Wisconsin Restaurant Association","countyNo":13,"maxItems":5}' \
  'https://api.apify.com/v2/acts/automation-lab~wisconsin-ccap-circuit-court-search/runs'
```

JavaScript with the Apify client:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/wisconsin-ccap-circuit-court-search').call({
  businessName: 'Wisconsin Restaurant Association', countyNo: 13, maxItems: 5
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 5 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/wisconsin-ccap-circuit-court-search').call(
    run_input={'businessName': 'Wisconsin Restaurant Association', 'countyNo': 13, 'maxItems': 5})
rows = client.dataset(run['defaultDatasetId']).list_items(limit=5).items
```

### MCP usage

Use the stable Actor-specific endpoint:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/wisconsin-ccap-circuit-court-search'
```

Equivalent HTTP configuration for Claude Desktop, Cursor and VS Code (use your client's HTTP-server settings):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/wisconsin-ccap-circuit-court-search"}}}
```

Configure authorized authentication in your client. Discover actual tool names and schemas with `tools/list`; Actor selection also supplies run/storage helpers and does not expose only one tool. Example prompt: “Search Wisconsin Restaurant Association in Dane County and show at most five public summary cases.”

For an authorized invocation, start once and retain the run ID and storage IDs. IDs are not result rows. `call-actor` may wait only 0–45 seconds (default 30). If pending, check the same run using `get-actor-run`, with 2/4/8-second backoff capped at 10 seconds and a 120-second total deadline. Set the client's timeout above its server wait plus transport margin. Recover a known run after client timeout; do not blindly restart. At the deadline report pending with the run ID. Failed runs contain partial evidence, not complete results.

After success, fetch bounded `get-dataset-items` pages using the returned dataset ID, explicit offset/limit and needed fields. An example consumer budget is 20 rows per page, at most 100 source rows and 64 KiB serialized UTF-8 across all pages, whichever comes first. Enforce bytes host-side before model injection; disclose omitted/oversized rows, continuation offset and truncation. Without client-side interception, do not claim a hard byte guarantee. These are consumer context budgets, not changes to Actor collection. Keep full exports outside model context. Discovery caching depends on client support; no token-savings guarantee is made.

### Legality, responsible use and privacy

Use records only for lawful purposes and verify consequential findings with the court. Public records can be incomplete, corrected, sealed, removed or associated with a different person. This is not legal advice or a consumer-reporting service. Do not use name matches alone for employment, housing, credit, insurance or other consequential decisions.

No AI model is used in extraction or output generation. For help, open an issue on the Actor's Apify page and include a run link without secrets.

The Actor saves only its documented summary fields. Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair; secret fields and URL queries are removed and reports are retained for 30 days. Your own input, dataset and log retention remain governed by your Apify settings; delete runs/storage through your account when no longer needed. Cookies are in-memory for one run only; the Actor creates no persistent cache or cross-run party database.

### FAQ and troubleshooting

**Why are no rows returned?** A valid source search can have no public matches. Try the exact known case and county, or verify the name manually. Empty output does not prove that no case exists.

**Why did a broad query fail?** The source may refuse too many results or impose access limits. Narrow your business/person name and county. The Actor does not silently return a partial search-error page as data.

**Why can I not open a source link automatically?** Detail access may require a CAPTCHA. This Actor deliberately does not access that route.

**Can I get docket events, charges or birth dates?** No. Those are outside this product's contract.

**Does it detect changes automatically?** No. Schedule snapshots and compare them downstream by `caseId`.

### Related workflows

This is a standalone Wisconsin summary-search workflow. No related Actor is required, and results are not enriched with cross-source personal profiles. For other products, browse [automation-lab](https://apify.com/automation-lab) and review each product's supported scope separately.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/wisconsin-ccap-circuit-court-search/changelog.md

# Actor input Schema

## `businessName` (type: `string`):

Business-name search using WCCA's native name matching. Trimmed before submission; partial names may match. Mutually exclusive with lastName, firstName and caseNo. No local substring or exact-name filtering is applied.

## `lastName` (type: `string`):

Person last-name search using WCCA's native matching; partial names may match. Exclusive with businessName and caseNo. Optionally narrow with firstName; names are not unique identities.

## `firstName` (type: `string`):

Optional native first-name criterion, combined with lastName (both criteria must match according to WCCA). Requires lastName. Not supported for business or case-number searches.

## `caseNo` (type: `string`):

Exact case number in YYYYTTNNNNNN format, for example 2026CV000001; trimmed and uppercased. Requires countyNo. Exclusive with all name fields. Returns summary rows, not docket or charge details.

## `countyNo` (type: `integer`):

Official WCCA county number (1–72), for example 13 for Dane. Required for caseNo; optional for names. When omitted in name mode, searches all counties supported by WCCA. Results are checked against this county.

## `maxItems` (type: `integer`):

Global maximum unique county/case identities saved per run, after deduplication in source order. Default 100, range 1–1000; zero/unlimited is unsupported. The source returns a full summary list before this limit is applied, so this does not limit upstream response size or guarantee complete source coverage.

## Actor input object example

```json
{
  "businessName": "Wisconsin Restaurant Association",
  "countyNo": 13,
  "maxItems": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

Deduplicated public summary cases.

# 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 = {
    "businessName": "Wisconsin Restaurant Association",
    "countyNo": 13,
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/wisconsin-ccap-circuit-court-search").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 = {
    "businessName": "Wisconsin Restaurant Association",
    "countyNo": 13,
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/wisconsin-ccap-circuit-court-search").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 '{
  "businessName": "Wisconsin Restaurant Association",
  "countyNo": 13,
  "maxItems": 5
}' |
apify call automation-lab/wisconsin-ccap-circuit-court-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/wisconsin-ccap-circuit-court-search"
        }
    }
}
```

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/Z6Rq1vCMfenNBhBPj/builds/Om4yqh5cBR1jGDfSS/openapi.json