# Baltimore City MD Tax Lien Certificates: Owners & Amounts (`lienintel/baltimore-city-md-tax-lien-certificates`) Actor

Search Baltimore City tax lien certificate sale records from 2019-2023. Get owner names, property addresses, lien, interest, fee and total amounts, assessed values and redemption detail. $0.015 per record.

- **URL**: https://apify.com/lienintel/baltimore-city-md-tax-lien-certificates.md
- **Developed by:** [LienIntel - UCC & Secured Lending Intelligence.](https://apify.com/lienintel) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.00 / 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

[![Baltimore City MD Tax Lien Certificates: Owners & Amounts](https://scrapers.lat/banners/baltimore-city-md-tax-lien-certificates.png)](https://console.apify.com/actors/eMNOElhNQTcMOoksF/input)

## Baltimore City MD Tax Lien Certificates: Owners & Amounts

Search the City of Baltimore tax lien certificate sale list and get the owner of record, property address, block and lot, sale year, the published lien, interest, legal-fee, miscellaneous and total amounts, assessed value and redemption detail as flat rows.

This is a dedicated Baltimore City tax-sale source.

Here is one real record from this actor. `source`, `source_page` are left out of this example and included in your dataset.

```json
{
  "record_id": "BALT-2019-287-6466-035",
  "state": "MD",
  "jurisdiction": "Baltimore City",
  "lien_type": "tax_lien_certificate",
  "lien_authority": "Baltimore City, Maryland",
  "tax_sale_year": "2019",
  "bidding_number": 287,
  "block": "6466",
  "lot": "035",
  "property_address": "0903 S EATON ST",
  "owner_name": "MERCHANT HILL, LLC",
  "occupancy_flag": "N",
  "land_use_code": "R",
  "council_district": "01",
  "zoning_district": "R-8",
  "liens_usd": 9000000,
  "interest_usd": 0,
  "legal_fees_usd": 0,
  "miscellaneous_usd": 0,
  "total_amount_usd": 9000000,
  "assessed_value_usd": 770433,
  "redemption_date": "2019-05-13",
  "redemption_name": null,
  "certificate_status": "void",
  "status_note": "-------VOID",
  "is_redeemed": false,
  "latitude": 39.28,
  "longitude": -76.56,
  "source_record_id": 3344,
  "observed_at": "2026-10-31T21:16:45.722Z"
}
```

**[Input](https://apify.com/lienintel/baltimore-city-md-tax-lien-certificates/input-schema) | [Output](https://apify.com/lienintel/baltimore-city-md-tax-lien-certificates/output-schema) | [Pricing](https://apify.com/lienintel/baltimore-city-md-tax-lien-certificates/pricing)**

![Coverage](https://img.shields.io/badge/Coverage-Baltimore%20City%2C%20Maryland-blue)
![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)
![Billing](https://img.shields.io/badge/Billing-Pay%20per%20result-brightgreen)

### Table of contents

- [What you get](#what-you-get)
- [Input and filters](#input-and-filters)
- [Use cases](#use-cases)
- [Coverage and freshness](#coverage-and-freshness)
- [Pricing](#pricing)
- [Comparison with other Apify actors](#comparison-with-other-apify-actors)
- [Related LienIntel actors](#related-lienintel-actors)
- [FAQ](#faq)
- [Run it through the Apify API](#run-it-through-the-apify-api)

### What you get

- **The owner of record.** The name Baltimore City publishes against each certificate, so a lead arrives with a party, not just a parcel number.
- **The property.** Street address, block, lot, council district, zoning district, land use code and the published latitude and longitude.
- **The money.** Lien amount, interest, legal fees, miscellaneous charges, total amount and assessed value, each as its own numeric USD field.
- **Redemption status.** Redemption date and redeeming party when the city publishes one, plus a derived `certificate_status` of `open`, `redeemed` or `void` and a boolean `is_redeemed` flag. Use it to separate certificates still outstanding from those already paid off.
- **Honest handling of city notes.** Baltimore City sometimes writes an administrative note such as `VOID` or `BILLS PAID/TS NOT ON PREV` in the redemption field. Those notes are returned in `status_note` and are never presented as a redeeming party. Void rows are excluded by default because their published total can be a placeholder.
- **Sale context.** Tax sale year and bidding number, so a certificate can be tied back to the sale it came from.
- **A stable `record_id`** built from the sale year, bidding number, block and lot, and one flat record per certificate row.

Each record can carry these 34 fields. A field the source does not publish for a record comes back as `null`.

| Field | Type | Description |
|---|---|---|
| `source` | string | Baltimore City Tax Lien Certificate Sale Properties |
| `source_page` | string | Public reference page for the source list |
| `state` | string | MD |
| `jurisdiction` | string | Baltimore City |
| `lien_type` | string | Normalized lien type, tax_lien_certificate |
| `lien_authority` | string | Taxing authority that offered the certificate, Baltimore City, Maryland |
| `record_id` | string | Stable record key built from the sale year, bidding number, block and lot |
| `tax_sale_year` | string | Tax sale year the certificate was offered, 2019 through 2023 |
| `bidding_number` | integer | Bidding number published for the certificate in that sale year |
| `block` | string | Baltimore City block number |
| `lot` | string | Baltimore City lot number |
| `property_address` | string | Property address published for the certificate |
| `owner_name` | string | Owner of record published for the property |
| `occupancy_flag` | string | Occupancy flag published by the city, D, H or N, kept as published |
| `land_use_code` | string | Land use code published by the city |
| `council_district` | string | Baltimore City council district, 01 through 14 |
| `zoning_district` | string | Zoning district published for the property |
| `liens_usd` | integer | Lien amount published for the certificate, in US dollars |
| `interest_usd` | integer | Interest amount published for the certificate, in US dollars |
| `legal_fees_usd` | integer | Legal fees published for the certificate, in US dollars |
| `miscellaneous_usd` | integer | Miscellaneous charges published for the certificate, in US dollars |
| `total_amount_usd` | integer | Total amount published for the certificate, in US dollars |
| `assessed_value_usd` | integer | Assessed value published for the property, in US dollars |
| `redemption_date` | string | Redemption date in YYYY-MM-DD form when the certificate was redeemed |
| `redemption_name` | string | Redeeming party published for the certificate; null when the city wrote an administrative note instead |
| `certificate_status` | string | Derived certificate state: open, redeemed or void |
| `status_note` | string | Administrative note the city wrote in the redemption field, for example VOID or BILLS PAID; null when a real party was published |
| `is_redeemed` | boolean | True only when the certificate is redeemed and not void |
| `latitude` | number | Latitude of the published property point |
| `longitude` | number | Longitude of the published property point |
| `source_record_id` | integer | Source record id |
| `observed_at` | string | Timestamp when this record was read from the source |
| `search_terms` | string | Full run search context, present on error rows only |
| `error` | string | Error message when no records were returned or the source failed; error records are not charged |

### Input and filters

All inputs are optional.

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `ownerNames` | array | no | (none) | Owner of record names to search, up to 20. Partial names are supported and matching is case-insensitive, for example SMITH, TRUST or PROPERTIES. Each name is searched separately and duplicate certificate rows are removed. |
| `propertyAddress` | string | no | `""` | Partial Baltimore street address, for example NORTH AVE or 1923 W NORTH. Case-insensitive. |
| `block` | string | no | `""` | Baltimore City block number, for example 0002 or 2. Numeric blocks are zero-padded automatically. Partial blocks are supported. |
| `lot` | string | no | `""` | Baltimore City lot number, for example 026 or 26. Numeric lots are zero-padded automatically. Partial lots are supported. |
| `taxSaleYears` | array | no | (none) | Tax sale years to include, for example 2023 or \[2022, 2023]. The published list covers 2019 through 2023. Leave empty for every published year. |
| `councilDistrict` | string | no | `""` | Baltimore City council district, 01 through 14. Numeric districts are zero-padded automatically. |
| `minTotalAmount` | number | no | `0` | Only certificates whose published total amount is at least this figure, in US dollars. For example 5000. |
| `maxTotalAmount` | number | no | (none) | Only certificates whose published total amount is at most this figure, in US dollars. Leave empty for no upper limit. |
| `redemptionStatus` | string | no | `"any"` | Include every certificate, only certificates with a published redemption date or redeeming party, or only certificates with no published redemption. Values: `any`, `redeemed`, `unredeemed`. |
| `includeVoidCertificates` | boolean | no | `false` | Baltimore City marks some rows VOID in the redemption field. Void rows are excluded by default because their published total can be a placeholder rather than a real balance. Turn this on to return them too, with certificate_status=void. |
| `sortBy` | string | no | `"sale_year_desc"` | Order of the returned certificates. The default puts the newest sale year first; amount sorts put the largest or smallest lien first. Values: `total_amount_desc`, `total_amount_asc`, `sale_year_desc`, `address_asc`, `owner_asc`. |
| `maxFilings` | integer | no | `25` | Maximum number of certificate records to return and charge, 1-1,000. Default 25. Free Apify users receive up to 10 results per run. |

A working example to paste into the Input tab:

```json
{
  "ownerNames": [
    "MERCHANT HILL"
  ],
  "includeVoidCertificates": true,
  "maxFilings": 3,
  "minTotalAmount": 0,
  "redemptionStatus": "any",
  "sortBy": "sale_year_desc"
}
```

### Use cases

- Study certificates sold at Baltimore tax sales by year, block and lot, with redemption status and assessed value.
- **Tax lien and tax deed investors** screening Baltimore certificates by amount, sale year and redemption status.
- **Surplus-funds and redemption researchers** finding certificates with a published redemption and the party that redeemed.
- **Distressed-property and vacant-property teams** combining Baltimore tax-sale records with their own outreach data.
- **Real-estate attorneys, title researchers and closing teams** checking whether a Baltimore property appeared in a tax sale and what was owed.

### Coverage and freshness

The published list covers the **2019, 2020, 2021, 2022 and 2023** tax sale years and contains **43,736 certificate rows**, of which **16,693** carry a positive total amount. The layer was last refreshed by the city in early 2025 and the newest published sale year is 2023; newer sale years are not in this source and are not invented by this actor.

Rows the city publishes with a zero total are still returned, because they show the property, owner and sale year even when the certificate carried no balance. Filter with `minTotalAmount` to drop them. Rows the city marks `VOID` are excluded by default; enable `includeVoidCertificates` to return them with `certificate_status=void`.

- Public-record research only. The output is not a consumer report, not an FCRA product, not a title examination and not legal, tax or investment advice.
- Data comes from the city's public certificate list over HTTPS.
- Baltimore City, not this actor, controls the list.
- Sale-year coverage reflects the published source: 2019 through 2023.

### Pricing

This actor uses pay-per-event pricing. These are the current Apify prices, read on 2026-11-06.

| Event | Price | When it is charged |
|---|---|---|
| `result` | $0.015 | Each record delivered to your dataset |
| `apify-actor-start` | $0.003 | When a run starts, once per GB of run memory with a minimum of one |

At the default 512 MB, a run that delivers 100 records costs $1.503.

- Apify asks for a maximum spend of at least $0.018 per run on this actor.
- Accounts on the free Apify plan receive up to 10 results per run.
- If nothing matches or the source fails, you get one row with an `error` field and no `result` charge. The start event still applies to the run.
- Set a maximum cost per run and the actor stops delivering results when it reaches that limit.

### Comparison with other Apify actors

No dedicated actor for this source on the Apify Store as of November 2026. We searched the public Store on 2026-11-06 with queries including "Baltimore City tax", "Baltimore City delinquent" and "Baltimore City lien", and we reviewed the listings for this source and data type. Broader actors exist: `outstanding_vegetable/tax-sale-monitor-southeast` watches tax sale portals in 170 counties in FL, OH, CO, AZ, MD, NJ, NY and NE. Their listings do not name this source, so we could not confirm that they cover it. Store listings change, so run the same search before you rely on this.

### Related LienIntel actors

Other public LienIntel actors for the same buyer:

- [Allegheny County PA Tax Liens: Dockets, Amounts & Assignees](https://apify.com/lienintel/allegheny-county-pa-tax-liens): delinquent property tax records in Allegheny County, Pennsylvania
- [Clermont County OH Delinquent Tax Liens: Owners & Amounts](https://apify.com/lienintel/clermont-county-oh-delinquent-tax-liens): delinquent property tax records in Clermont County, Ohio
- [Cochise County AZ Tax Lien Parcels: Owners & Amounts](https://apify.com/lienintel/cochise-county-az-tax-liens): delinquent property tax records in Cochise County, Arizona
- [Guilford County NC Tax Liens: Delinquent Owners & Amounts](https://apify.com/lienintel/guilford-county-nc-tax-lien-filings): delinquent property tax records in Guilford County, North Carolina

### FAQ

**Is this a credit report?**

No. These are tax records published by the taxing authority. They must not be used to decide credit, employment, housing or insurance eligibility.

**Are the amounts final payoff figures?**

No. Treat them as published at the time of the run. Confirm a payoff with the tax office before relying on it.

**What can I filter by?**

The input accepts `ownerNames`, `propertyAddress`, `block`, `lot`, `taxSaleYears`, `councilDistrict`, `minTotalAmount`, `redemptionStatus`, `includeVoidCertificates` and `sortBy`. The Input and filters section explains each one.

**Can I run it on a schedule?**

Yes. Create an Apify schedule for the actor, then send the dataset to your database, a spreadsheet or a webhook.

### Run it through the Apify API

Replace `<TOKEN>` with your Apify API token.

```bash
curl -X POST "https://api.apify.com/v2/acts/lienintel~baltimore-city-md-tax-lien-certificates/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"ownerNames": ["MERCHANT HILL"], "includeVoidCertificates": true, "maxFilings": 3, "minTotalAmount": 0, "redemptionStatus": "any", "sortBy": "sale_year_desc"}'
```

With the Apify CLI:

```bash
apify call lienintel/baltimore-city-md-tax-lien-certificates --input '{"ownerNames": ["MERCHANT HILL"], "includeVoidCertificates": true, "maxFilings": 3, "minTotalAmount": 0, "redemptionStatus": "any", "sortBy": "sale_year_desc"}'
```

Every run writes to a dataset that you can export as JSON, CSV or Excel from the Storage tab or through the Apify API.

***

*LienIntel is an independent data provider and is not affiliated with any government office named on this page. Records are public and are provided for research and workflow automation. This is not a certified search and not a consumer report under the FCRA.*

# Actor input Schema

## `ownerNames` (type: `array`):

Owner of record names to search, up to 20. Partial names are supported and matching is case-insensitive, for example SMITH, TRUST or PROPERTIES. Each name is searched separately and duplicate certificate rows are removed.

## `propertyAddress` (type: `string`):

Partial Baltimore street address, for example NORTH AVE or 1923 W NORTH. Case-insensitive.

## `block` (type: `string`):

Baltimore City block number, for example 0002 or 2. Numeric blocks are zero-padded automatically. Partial blocks are supported.

## `lot` (type: `string`):

Baltimore City lot number, for example 026 or 26. Numeric lots are zero-padded automatically. Partial lots are supported.

## `taxSaleYears` (type: `array`):

Tax sale years to include, for example 2023 or \[2022, 2023]. The published list covers 2019 through 2023. Leave empty for every published year.

## `councilDistrict` (type: `string`):

Baltimore City council district, 01 through 14. Numeric districts are zero-padded automatically.

## `minTotalAmount` (type: `number`):

Only certificates whose published total amount is at least this figure, in US dollars. For example 5000.

## `maxTotalAmount` (type: `number`):

Only certificates whose published total amount is at most this figure, in US dollars. Leave empty for no upper limit.

## `redemptionStatus` (type: `string`):

Include every certificate, only certificates with a published redemption date or redeeming party, or only certificates with no published redemption.

## `includeVoidCertificates` (type: `boolean`):

Baltimore City marks some rows VOID in the redemption field. Void rows are excluded by default because their published total can be a placeholder rather than a real balance. Turn this on to return them too, with certificate_status=void.

## `sortBy` (type: `string`):

Order of the returned certificates. The default puts the newest sale year first; amount sorts put the largest or smallest lien first.

## `maxFilings` (type: `integer`):

Maximum number of certificate records to return and charge, 1-1,000. Default 25. Free Apify users receive up to 10 results per run.

## Actor input object example

```json
{
  "propertyAddress": "",
  "block": "",
  "lot": "",
  "councilDistrict": "",
  "minTotalAmount": 0,
  "redemptionStatus": "any",
  "includeVoidCertificates": false,
  "sortBy": "sale_year_desc",
  "maxFilings": 25
}
```

# Actor output Schema

## `results` (type: `string`):

One row per Baltimore City tax lien certificate, with the owner of record, property address, block and lot, sale year, published lien, interest, legal-fee and total amounts, assessed value and redemption detail.

# 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("lienintel/baltimore-city-md-tax-lien-certificates").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("lienintel/baltimore-city-md-tax-lien-certificates").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 lienintel/baltimore-city-md-tax-lien-certificates --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lienintel/baltimore-city-md-tax-lien-certificates"
        }
    }
}
```

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/eMNOElhNQTcMOoksF/builds/wu2mF4XltIkF5AOdl/openapi.json
