# MD PG County Tax-Sale Foreclosures (`j0401/md-pg-foreclosures`) Actor

Prince George's County, MD tax-sale foreclosure register (~78.7k, 2009-present, open data): every property submitted for county tax sale - tax account, property id, submission date, address, occupied flag. Distressed-property diligence: an address's full history or a fresh-submission sweep.

- **URL**: https://apify.com/j0401/md-pg-foreclosures.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.30 / 1,000 md prince george's county foreclosure records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Prince George's County (MD) Tax-Sale Foreclosures

The county's property foreclosure register - every property Prince George's
County has submitted for tax sale, 2009 to the present, in one queryable
dataset. Distressed-property diligence: the full tax-sale history of one
address, or a sweep of what's fresh across a city.

### Data

Prince George's County, Maryland open data (public tax-sale register).
**~78,700 properties, 2009-present** - each a single submission of a
delinquent-tax property to the county's tax sale.

Each record carries:

- **Tax account number** - the county's tax key for the property (e.g.
  17060464123\)
- **County property id** - the county's internal property identifier
- **Submission date** - when the property was submitted for tax sale
- **Street address, city, ZIP, location** - the full property address
- **Occupied flag** - whether the address was occupied at submission
  (`YES` / `NO`)
- **Property description** - a short line where the county records one

A note on the register's rhythm, stated plainly: tax-sale submissions arrive in
seasonal batches, not as a steady stream - the most recent submissions in the
register are from July 2026, and a county typically processes them in annual
cycles. This is the deep history of which properties have been through the
county's tax-sale process, ideal for property history and sweeps - not a
daily feed of fresh notices.

### Low cost

**From $0.0003 per record.**

County tax-sale data is published as a flat table where only a fraction of rows
carry a real occupancy flag and submissions cluster into batches - fine for
browsing the county's portal, painful if you want to actually cut it by place,
status or date. We made the register directly queryable: `taxAccountNumber` /
`propertyId` / `address` / `city` / `zip` / `occupied` / submission-date
windows all filter before a record returns, and `groupBy` (counts by city /
zip / occupancy / submission year) comes back as clean server counts. You
query a foreclosure register that behaves like a database; the cleanup stays
on our side.

**Every record is one flat JSON object** - no PDFs, no portal pagination.

### Use cases

- **Property history** - every time a given property or address went through
  the county's tax-sale process, with its tax account and submission date
- **Distressed-property diligence** - confirm whether a property has been
  submitted for tax sale, when, and in which city
- **Market sweeps** - aggregate submissions by city or year to see the shape
  of tax-sale activity across the county

### Inputs

| Field | What it does |
|---|---|
| `taxAccountNumber` | exact county tax account lookup |
| `propertyId` | county property identifier |
| `address` / `city` / `zip` | find by place |
| `occupied` | YES / NO (only ~4% of properties carry a real flag) |
| `submittedFrom` / `submittedTo` | submission-date window |
| `recentDays` | submissions in the last N days (batches may return little) |
| `aggregate` + `groupBy` | counts by city / zip / occupancy / submission year |

### Output fields

`submittedDate` / `taxAccountNumber` / `propertyId` / `address` / `city` /
`zip` / `occupied` / `propertyDescription` / `location`.

> Honesty note: the county records a real occupied / vacant flag (`YES` /
> `NO`) on only ~4% of properties - the remaining ~96% are published as
> `Unavailable`. The `occupied` field is returned exactly as the county
> published it, never filled in. `propertyId` is the county's internal id, not
> a stable key across years.

Source: Prince George's County open data (tax-sale foreclosure register,
public records).

# Actor input Schema

## `taxAccountNumber` (type: `string`):

Exact county tax account number (e.g. 17060464123).

## `propertyId` (type: `string`):

County property identifier (not a stable key across years).

## `address` (type: `string`):

Street address substring (e.g. 'Canterbury').

## `city` (type: `string`):

City (e.g. 'Bowie', 'Temple Hills').

## `zip` (type: `string`):

ZIP code (e.g. 20748).

## `occupied` (type: `string`):

Whether the address was occupied at submission. Blank = all. Note the county records a real YES/NO on only ~4% of properties (the rest are 'Unavailable').

## `submittedFrom` (type: `string`):

Only properties submitted for tax sale on/after this date (YYYY-MM-DD).

## `submittedTo` (type: `string`):

Only properties submitted on/before this date (YYYY-MM-DD).

## `recentDays` (type: `integer`):

Only properties submitted in the last N days. Submissions arrive in seasonal batches (latest 2026-07), so a recent window may return little.

## `aggregate` (type: `boolean`):

When on, returns one summary record per group (see groupBy) with a count instead of individual properties.

## `groupBy` (type: `string`):

Which dimension to aggregate over. submittedYear = the batch rhythm of tax-sale submissions.

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

Cap the number of records pushed (0 = up to ~10k per run - practical page limit). Aggregates have a few hundred groups max.

## Actor input object example

```json
{
  "taxAccountNumber": "",
  "propertyId": "",
  "address": "",
  "city": "",
  "zip": "",
  "occupied": "",
  "submittedFrom": "",
  "submittedTo": "",
  "recentDays": 0,
  "aggregate": false,
  "groupBy": "city",
  "maxResults": 200
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

Prince George's County tax-sale foreclosure records or aggregates - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("j0401/md-pg-foreclosures").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("j0401/md-pg-foreclosures").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 '{}' |
apify call j0401/md-pg-foreclosures --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/md-pg-foreclosures"
        }
    }
}

```

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/emNW2NrHJGEbSJdM5/builds/OLYNSIUceb50iRDnc/openapi.json