Standard Operating Procedure

MLS Listing JSON Import

Use AI to convert any Matrix MLS detail page into a structured JSON file, then import it into your Agent Dashboard to auto-fill a new listing in minutes.

~5 minutes end-to-end
25–28 fields auto-filled
Works with Claude & other AI

What This Process Does

Instead of entering every field manually when adding a new listing, you give an AI assistant the MLS detail page. The AI extracts and structures the data, saves it as a .json file, and you drop that file into the listing form. Most fields fill instantly — all you add are the listing agent, photos, and a few items that aren’t on the MLS page.

25–28
Fields auto-filled

2–5
Fields to review

<5 min
MLS → saved draft

.json
File format used

Prerequisites — Set Up Once

Choose the option that matches how you prefer to work. You only need to do this setup once.

B
Claude.ai or Claude Cowork (Desktop)
Works with screenshots or copy-pasted MLS text

  1. 1 Go to claude.ai or open Claude Cowork and start a new conversation.
  2. 2 Paste the full contents of TPG_MLS_JSON_Prompt.md as your first message and press Enter.
  3. 3 In your next message, attach a screenshot of the full MLS page and say “Convert this listing.”

Cowork tip: Install the tpg-mls-to-json skill folder into ~/.claude/skills/ and Claude will trigger automatically whenever you share MLS data — no need to paste the prompt each time.

C
Any Other AI (ChatGPT, Gemini, etc.)
Works with any capable LLM

  1. 1 Open a new chat in your preferred AI tool.
  2. 2 Paste the full contents of TPG_MLS_JSON_Prompt.md as your first message.
  3. 3 Share the MLS listing data (screenshot, pasted text, or PDF) and ask it to convert the listing.

The Prompt — Access & Copy

This prompt is stored as a shared Claude Skill. Click below to open it directly, or copy the full text to set up your own shortcut or paste into any AI tool.


Claude Shared Skill
TPG — MLS to JSON
Opens the skill in claude.ai — click Add to Claude to add it to your account. Requires a Claude account.

Full Prompt Text — TPG_MLS_JSON_Prompt.md
You are converting a Matrix MLS listing page into a structured JSON file for The Parker Group's listing import tool. The user will provide a screenshot, PDF, or pasted text of an MLS detail page.

## Output rules

- Produce one JSON file per listing
- File name: `[Street Number] [Street Name] [City] [State].json` — use spaces, no underscores, no ZIP, state abbreviation only
  - Example: `324 Jebb Rd Camden Wyoming DE.json`
- Pretty-print with 2-space indent
- Use `null` for any field that is blank or not present — never omit a key

## JSON structure

Use this exact nested structure. Do NOT place all fields at the root level.

```json
{
  "address":        "324 Jebb Rd, Camden Wyoming, DE 19934",
  "status":         "Active",
  "property_type":  "Residential",
  "list_price":     650000,
  "remarks_public": "Full public remarks text verbatim here",

  "property_details": {
    "mls_number":            "DEKT2046558",
    "beds":                  4,
    "baths_full":            2,
    "baths_half":            0,
    "above_grade_fin_sqft":  1898,
    "year_built":            "1925",
    "levels_stories":        "2",
    "waterfront":            false,
    "basement":              false,
    "garage":                false,
    "structure_type":        "Detached"
  },

  "building_info": {
    "yr_major_reno_remodel": null,
    "flooring_type":         ["Carpet", "Ceramic Tile", "Luxury Vinyl Plank"]
  },

  "lot": {
    "lot_acres": 15.06
  },

  "location": {
    "county":       "Kent, DE",
    "subdiv_neigh": "NONE AVAILABLE"
  },

  "interior_features": [
    "Bathroom - Stall Shower",
    "Ceiling Fan(s)",
    "Crown Molding",
    "Fireplace - Wood",
    "Refrigerator",
    "Dishwasher",
    "Washer",
    "Dryer"
  ],

  "exterior_features": {
    "pool": "No Pool"
  },

  "utilities": {
    "heating":      "Hot Water Radiator",
    "water_source": "Well",
    "sewer":        "Septic Tank",
    "ceiling_fans": true
  },

  "listing_details": {
    "listing_term_begins": "02/11/2026",
    "original_price":      650000
  }
}
```

## Field extraction rules

### Root level
| MLS Label | JSON field | Rule |
|---|---|---|
| Header — Address | `address` | Full string including city, state, ZIP |
| Header — Status | `status` | `"Active"`, `"Coming Soon"`, `"Under Contract"`, `"Pending"`, `"Sold"` |
| Header — Property Type | `property_type` | `"Residential"`, `"Land"`, `"Commercial"`, `"Multi-Family"` |
| List Price | `list_price` | **Integer** — strip $ and commas: `$650,000` → `650000` |
| Remarks — Public | `remarks_public` | Full text verbatim. Key MUST be `remarks_public` not `"remarks"` |

### property_details
| MLS Label | Field | Rule |
|---|---|---|
| MLS # | `mls_number` | String |
| Beds | `beds` | Integer |
| Baths (full) | `baths_full` | `"2 / 1"` → number before slash: `2` |
| Baths (half) | `baths_half` | `"2 / 1"` → number after slash: `1` |
| Above Grade Fin SQFT | `above_grade_fin_sqft` | `"1,898 / Estimated"` → first number as integer: `1898` |
| Year Built | `year_built` | 4-digit string: `"1925"` |
| Levels/Stories | `levels_stories` | String: `"1"`, `"2"` |
| Waterfront | `waterfront` | Boolean: `"Yes"` → `true`, `"No"` → `false` |
| Basement | `basement` | Boolean |
| Garage | `garage` | Boolean |
| Structure Type | `structure_type` | `"Detached"`, `"Attached"`, `"Interior Row/Townhouse"` |

### building_info
| MLS Label | Field | Rule |
|---|---|---|
| Yr Major Reno/Remodel | `yr_major_reno_remodel` | 4-digit string or `null` |
| Flooring Type | `flooring_type` | Array — split on commas |

### lot
| MLS Label | Field | Rule |
|---|---|---|
| Lot Acres / SQFT | `lot_acres` | `"15.06a / 655,814sf"` → acres as float: `15.06` |

### location
| MLS Label | Field | Rule |
|---|---|---|
| County | `county` | Include state suffix: `"Kent, DE"` — the import script strips it |
| Subdiv / Neigh | `subdiv_neigh` | Keep `"NONE AVAILABLE"` as-is |

### interior_features (root-level array)
Split on semicolons. Each item becomes one array entry. Drop `"No Fireplace"` and `"Accessibility Features: None"`. Carpet goes in `building_info.flooring_type`, not here. Include appliances (Refrigerator, Dishwasher, etc.) in this array — the import tool keyword-matches them.

### exterior_features (object, not array)
| MLS Label | Field | Rule |
|---|---|---|
| Pool | `pool` | `"Pool: No Pool"` → `"No Pool"`. Otherwise describe the pool type. |

### utilities (parse from semicolon-delimited Utilities string)
| Segment | Field | Rule |
|---|---|---|
| `Heating: …` | `heating` | Value after "Heating:" |
| `Water Source: …` | `water_source` | `"Well"`, `"Public"` |
| `Sewer: …` | `sewer` | `"Septic Tank"`, `"Public Sewer"` |
| `Ceiling Fan(s)` anywhere | `ceiling_fans` | Boolean `true` if present |

### listing_details
| MLS Label | Field | Rule |
|---|---|---|
| Listing Term Begins | `listing_term_begins` | Keep `MM/DD/YYYY` format |
| Original List Price | `original_price` | Integer, no $ or commas |

## Common mistakes to avoid

- **Never flatten** `mls_number`, `beds`, `baths_full`, `year_built` etc. to the root — they MUST be inside `property_details`
- **`exterior_features` is an object** `{ "pool": "..." }` — not an array `[]`
- **`list_price` must be an integer** — not the string `"$650,000"`
- **Key is `remarks_public`** — not `"remarks"`
- **Split baths** — `"2 / 0"` → `baths_full: 2, baths_half: 0`
- **Sq ft as integer** — `"1,898 / Estimated"` → `1898`

After producing the JSON, tell the user:
1. The filename to save it as
2. Any fields that were blank or unclear in the source data (so they can fill them in manually)

Step-by-Step Workflow

1
Navigate to the MLS Listing

Log into Matrix (or your MLS portal) and open the full detail page for the listing you want to add. Make sure you’re on the complete detail view — not a search results card — so all sections are visible: General Description, Location, Building Info, Lot, Interior Features, Utilities, and Listing Details.

2
Run the AI Conversion

Use whichever method you set up in Prerequisites:

Chrome Extension
With the listing page open, click the Claude extension icon. Type /mls-to-json and press Enter. Claude reads the live page and generates the JSON in real time.

Claude.ai / Cowork
Take a screenshot of the full MLS detail page, attach it to Claude, and say “Convert this listing.”

The AI reads every section of the MLS page and produces a complete, correctly structured JSON object. You’ll see it work through the fields in real time.


The Chrome extension can read the page directly — you don’t need to scroll, copy, or take screenshots. It processes the entire MLS detail page automatically.

3
Review the AI Output

Once finished, the AI will display the completed JSON and flag any fields it couldn’t confidently read. Look for a note at the end of its response listing fields that were blank, partially obscured, or unclear.

Common fields that may need a quick check:

  • Heating type — small text in the MLS Utilities section
  • Sewer type — same area
  • Year renovated — often blank on the MLS page
  • MLS number — verify it matches what you see in Matrix
  • Listing date — verify the format is MM/DD/YYYY

If any field looks wrong, you can either correct it in the JSON before downloading, or fill it in manually inside the listing form after import — whichever is easier.

4
Download the JSON File

Chrome Extension
The download triggers automatically. The file appears in your Downloads folder named after the address — e.g. 324 Jebb Rd Camden Wyoming DE.json

Claude.ai / Cowork
Copy the JSON text, paste into a text editor (Notepad, TextEdit), and save as [Address] [City] [State].json — e.g. 7592 Buckman Ave Salisbury MD.json


File naming convention: Street address + city + state abbreviation, separated by spaces. No ZIP code, no underscores, no special characters.

5
Navigate to Your Agent Dashboard

Go to theparkergroup.com and sign in. Click your name in the top-right corner to open the account menu, then select Dashboard.

add listing

Navigate to your listings and click Add Listing

6
Start a New Listing

On the Dashboard, scroll down to the My Listings section and click the + Add Listing button in the top-right corner.

This opens a blank multi-step listing form (11 steps: Address & Agent, Property Details, Features, Construction, Description, Financial, Sale Info, Photos & Media, Sellers, Occupancy, and Readiness) with the Import from MLS JSON panel at the top.


You don’t need to fill all steps before saving — save a draft at any point and return later to add photos, financial details, and other information.

7
Import the JSON File

At the top of the new listing form, you’ll see the Import from MLS JSON panel with a dashed drop zone.

  • Drag and drop the .json file from your Downloads folder onto the drop zone, or
  • Click Browse… and select the file from your Downloads folder
upload json

Import the MLS JSON using the drop zone at the top of the Add Listing form

The import runs instantly. The form auto-scrolls to Step 1 — Address & Agent where you can see all the filled-in fields and the auto-generated title preview.

8
Review the Import Results

A green confirmation banner shows how many fields were imported successfully, with a green chip for every field that mapped correctly. A typical import maps 25–28 fields.

verify fields

Review and verify mapped fields.

Below the green chips, you may see an orange warning: “X fields could not be mapped.” Click the arrow to expand it. Common unmapped fields and where to find them:

Unmapped Fields Reference
Unmapped Field Where to Fill It In
Waterfront Step 3 → Features → Property Features checkboxes
Yr Renovated Step 2 → Property Details → Age & History
Sewer Step 4 → Construction → Utilities & Services → Sewer dropdown
Heating Step 4 → Construction → HVAC & Hot Water → Heating System dropdown
Listing Agent Step 1 → Listing Setup → always set manually

9
Fill In Missing Information

Navigate through the steps using the tab bar and fill in any unmapped fields. A few things to always check:

  • Listing Agent (Step 1) — required before publishing
  • Description (Step 5) — the MLS public remarks are auto-filled; edit and improve them if needed
  • Photos (Step 8) — upload the primary photo and gallery; these can’t come from the JSON
  • Financial (Step 6) — tax info, HOA details if applicable

You don’t need to complete every step now. Save a draft and come back to add photos, seller info, and other details whenever you’re ready.

10
Save Draft

Click the Save Draft button on any step to save your progress. The listing will appear in My Listings on your Dashboard with a DRAFT badge.

From your draft you can return at any time to:

  • Upload photos and media
  • Complete remaining steps (Financial, Sale Info, Sellers, Occupancy, Readiness)
  • Edit any auto-filled fields before publishing

When ready to publish, navigate to Step 8 — Photos & Media and click Publish Listing at the bottom of the form.

Quick Reference — What the JSON Auto-Fills

Fields by Form Step
Form Step Auto-Filled from JSON Always Manual
1 — Address & Agent Street number, name, type, city, state, ZIP, property type, listing status, county, subdivision Auto Listing agent Manual
2 — Property Details Price, beds, full baths, half baths, sq ft, lot acres, year built, stories, year renovated, listing date, basement Y/N Auto Garage details, condition, style Manual
3 — Features Interior feature checkboxes, flooring, appliances, pool Y/N Auto Exterior & property features Manual
4 — Construction Water source, sewer, heating type (when dropdown matches) Auto Roof, foundation, cooling, electric Manual
5 — Description Full property description (from MLS public remarks) Auto Highlights, internal notes Manual
6–11 MLS number Auto Tax info, HOA, photos, seller info, occupancy, readiness Manual

Troubleshooting

The import zone doesn’t appear when I click Add Listing.
The JSON import zone only shows when adding a new listing. If you’re editing an existing one, the zone is hidden by design. If the listing already exists in the system (matched by MLS number), the import will offer to redirect you to the edit page for that listing instead of creating a duplicate.

More than 10 fields were skipped.
This usually means the JSON uses a flat structure instead of the required nested structure. Make sure the AI used the prompt from TPG_MLS_JSON_Prompt.md exactly — older or generic prompts may produce a flat format the import tool can’t read. Fields like mls_number, beds, and baths_full must be inside the property_details sub-object.

The price didn’t import.
The price must be a plain integer in the JSON (e.g. 650000), not a formatted string like "$650,000". Open the .json file in a text editor, correct the value, save, and re-import.

The description field is empty after import.
The JSON key must be remarks_public exactly. If the AI used "remarks" instead, the description won’t map. Open the .json file, rename the key to remarks_public, save, and re-import.

The Chrome extension shortcut isn’t working.
Make sure the full prompt text from TPG_MLS_JSON_Prompt.md was pasted into the shortcut body — the shortcut needs the complete JSON schema and field rules to work correctly. If only the title was pasted, Claude won’t have the instructions it needs.

The JSON was generated but the download didn’t trigger automatically.
In the Chrome extension, copy the JSON text from Claude’s response, open a plain text editor on your computer, paste it in, and save the file with the address as the filename and .json as the extension — for example: 324 Jebb Rd Camden Wyoming DE.json