Connect your CRM to Patch by Stash

Your clients already keep their most valuable asset in your CRM: thousands of properties and the owners behind them. What most CRMs can’t tell an agent is what is happening to those properties right now. Which ones just listed with someone else? Which owners have held for 20 years? Which listings did the office miss last quarter, and who won them?

That is what Patch by Stash does. This guide is for CRM product, partnership and development teams who want to offer it. It explains how a Patch CRM integration works, what it costs your clients, and how little you need to build.

In this guide:

• What Patch does with your clients’ properties
• The four steps: become a partner, connect the client, send the properties, use what Patch finds
• The endpoints and fields your developers need, from geocoding to the Property Pipeline
• Reading the analysed database back, and searching it in plain English
• The option to let Stash run the sync for you
• Pricing per record, and billing through Stash or wholesale through you

Why a Patch CRM integration matters to your clients

A CRM holds the relationships. Stash holds the property data. On their own, each answers half the question an agent asks every morning: who in my database should I call today, and why?

Once a CRM is connected, Patch monitors every property in the client’s database. When something changes, the agent knows:

• Just listed: a property in their database comes on the market, even when it lists with another agency.
• Missed listings: every property that listed with a competitor, with price changes, the estimated commission, and a nudge when the agency agreement is likely to be ending.
• Database health: the share of owner-occupiers and renters, and how long owners have held (1 year, 2 to 5, 5 to 10, 10 to 20, 20 to 30 and 30+ years).
• Coverage: how much of their patch the database actually covers, and the long-held homes they don’t know yet.

None of this needs your team to buy property data, build monitoring or maintain an address-matching engine. Stash does that work. Your CRM provides the list of properties.

Step 1: become an integration partner

Talk to the Stash partnerships team. Once you’re set up, Stash issues your CRM an integrator API key. Your CRM sends it on every call in the x-integrator-api-key header. On its own it reads nothing: it identifies your CRM as an approved partner and only works alongside a client’s key.

Step 2: your mutual client connects

A client who uses both your CRM and Stash creates an API key in their Stash account and pastes it into your CRM. Your CRM sends it next to the integrator key, either as a Bearer token or in the x-api-key header.

Check the key before you sync anything. GET /account returns 200 when the account has an active Stash subscription or trial, 403 when it’s inactive and 401 when the key is wrong. Show the agent a clear “reconnect” or “activate Patch” message rather than failing silently. Team members inherit their team owner’s plan, and GET /account/team returns seats and members for an owner or admin key.

The client owns their key and can revoke it at any time, which stops your CRM’s access to their Stash account.

Step 3: send the client’s properties to Patch

Match each address to a Stash property

Patch works with Stash property IDs. Match each address in your CRM with the geocode endpoints and store the Stash ID against your record, so you only match it once.

• GET /properties/geocode?address=… returns the best match for one address.
• POST /properties/geocode takes matching criteria in the request body. See the API docs for the format.

Post the properties to the pipeline

The Property Pipeline is the client’s database in Stash and the source for everything Patch does. Every call acts on the client’s pipeline (the team owner’s when the office shares one).

• One at a time: POST /property-pipeline adds a property. Re-adding a removed property restores it.
• In bulk: POST /property-pipeline/batch takes up to 500 properties per call in two lists: upsert adds, restores or updates, and delete removes. Each item gets its own outcome (created, restored, updated, deleted, not found or error), so one bad record doesn’t stop the rest. Retry only the failures.
• Changes: PATCH /property-pipeline/{propertyId} updates one record, and DELETE /property-pipeline/{propertyId} removes it.

POST /property-pipeline/batch
x-integrator-api-key: <your integrator key>
x-api-key: <client account key>

{
  "upsert": [
    { "propertyId": "<stash-property-id>", "status": "Prospect",
      "tags": ["Past vendor"], "crmReference": "CRM-10482" }
  ],
  "delete": ["<stash-property-id>"]
}

Statuses and tags are optional

If you want your CRM’s stages and labels to carry across, map them with the statuses endpoints (/property-pipeline/statuses: list, create, update, delete) and the tags endpoints (/property-pipeline/tags). Create them once when the client connects, then refer to them by title. If you skip this, properties land in the client’s default status. An unknown status returns a clear error that lists the statuses available.

Step 4: Patch analyses the database

Once properties land in the pipeline, Patch starts monitoring them straight away and runs its analysis in the background. Allow about an hour for a full database. The analysis enriches every property with Stash data and tags, so the client’s database can be segmented: owner-occupiers vs renters, how long owners have held, property features, and what has listed or sold.

Read the pipeline back, enriched

GET /property-pipeline lists the client’s pipeline in pages of 100, with a total count, and ?crmReference= returns the record for one of your IDs. Every record comes back with your own fields (status, tags, comments, crmReference, created and updated dates) plus a full Stash property record:

That’s enough to segment the database straight away: owner-occupiers who have held for 10+ years, homes on big blocks, properties now for sale or for rent, or the top value bracket by AVM. Because your own ID comes back on every record, you can match results to your data without another lookup. The client’s own home and investment properties in Stash aren’t included.

Search the client’s database in plain English

Agents ask questions in their own words: “owner-occupied houses with a pool”, “renovators held more than 20 years”. Two calls turn that into a search across the client’s CRM properties:

1. POST /properties/generate-search-request takes the plain-English query and returns a curated search request, converting the words into Stash filters and property tags.
2. POST /properties/search runs that request, limited to the client’s own pipeline, and returns matching properties with a match score. POST /properties then returns full detail for any single property.

That gives your CRM a natural-language search over its own data, without building a tagging engine.

Analyse your CRM with live property data to create segments, in Stash or inside your own CRM.

Targeted outreach to your CRM cohorts

Once the database is segmented, your clients can build cohorts from it: owner-occupiers who have held for 10+ years, past vendors with a pool, every property tagged with a pipeline status. Then they can reach each cohort with the marketing tools already in your CRM, new tools you build on Stash data, or the Stash tools below, all through the same API.

Prospect beyond the database COMING SOON

Patch also shows agents what their CRM doesn’t hold. Mapping the database against every property in their suburbs gives a property-level view of market share: which homes they have a relationship with, which they don’t, and where the long-held owners they’ve never contacted are.

From there, agents can prospect for properties they don’t have and, with your CRM’s permission, sync the new records back into your CRM, so prospecting and follow-up stay in one system. It isn’t always the right move (adding thousands of cold records can clutter a database), so it works best as a deliberate choice: a target street, a building era, or long-held owners in a farm area.

Illustrative display only. Agents can view the properties not in their CRM on Stash, or through your CRM’s own mapping tools.

Pricing and billing

Patch is priced per record: ~5c per property per month in a client’s connected database. A typical agent database of 3,000 properties costs $150 + GST per month, with volume discounts for larger databases.

Billing works either way round:

• Stash bills the client: the agency pays Stash directly and your CRM simply connects.
• Wholesale through your CRM: we’re considering wholesale options for CRMs that want to bundle Patch into their own plans. Talk to our partnerships team if that suits you.

Clients also need an active Stash account for their key to work, which GET /account confirms.