Connect Podio to Propera with GlobiFlow

Loom walkthrough goes here (embed coming soon).

Overview

Podio Workflow Automation (still widely known as GlobiFlow) includes a Remote HTTP Call action that can POST to Propera's API and read the JSON response back into your Podio fields. That means a fully native Podio integration with no extra subscription beyond Podio Premium.

What you'll build

One GlobiFlow flow: trigger on item create or update → Remote HTTP Call (Propera) → parse the response → Update Item.

Before you start

A Propera account on the Pro or Business plan, and a Propera API key (Step 1).
Podio with Workflow Automation (GlobiFlow) enabled (included with Podio Premium).
A Podio app/item with fields for the address, property type, beds, baths, sqft, year, comp radius, and a status field plus result fields (ARV, summary, notes).

Step 1 — Generate your Propera API key

In Propera, go to Account Settings → API Keys, click Generate API Key, name it (for example Podio), and copy it. It's shown only once.

Screenshot: the API Keys card in Account Settings.

Step 2 — Create a flow with a "ready" trigger

In GlobiFlow, create a flow on your leads app triggered when an item is created or updated. Add a filter so it only runs when a status field equals something like Run ARV, that way the analysis runs only when you say the lead is ready.

Step 3 — Add a Remote HTTP Call action

Method/URL: POST to https://getpropera.com/api/v1/arv
Headers (open the (OPT) header section): Content-Type:application/json and X-API-Key:YOUR_KEY
POST Params: the JSON body, with your Podio field tokens inserted:

{
  "address": "[(Lead) Property Address]",
  "property_type": "[(Lead) Property Type]",
  "bedrooms": "[(Lead) Bedrooms]",
  "bathrooms": "[(Lead) Bathrooms]",
  "sqft": "[(Lead) Square Footage]",
  "year_built": "[(Lead) Year Built]",
  "comp_radius": "[(Lead) Comp Radius (miles)]",
  "soft_errors": "true"
}

Keep "soft_errors": "true" in the body. GlobiFlow treats any non-200 response from a Remote HTTP Call as a flow error and stops the flow at that step, so your Update Item action never runs and the lead is left with nothing written to it. With soft_errors on, Propera answers every failure (bad address, not enough comps, revoked key, plan limit) with HTTP 200 and success: false, and the flow carries on to your Update Item step where the error calculation fills your Error field. The real HTTP code is still in the response as http_status.

Use your own field tokens. GlobiFlow tokens are [(Item Title) Field Label] — the part in parentheses is the app's item title (the singular item name, e.g. an app called "Seller Leads" has items titled Lead), and the labels must match your fields exactly. Swap both for whatever yours are called, and insert them from GlobiFlow's token picker rather than typing them by hand. Also wrap every token in quotes, including the numbers: a Podio number field can render with a comma (2,200) or be empty on a partly filled lead, and an unquoted token there would produce invalid JSON. Quoting keeps the body valid; Propera reads the numbers either way.

(See the GlobiFlow Remote HTTP Call docs.)

Step 4 — Parse the response and update the item

The Remote HTTP Call captures Propera's JSON response into a variable. Give it a name (for example propera) in the call's Capture Result setting. Then add an Update Item action and extract each value with GlobiFlow's preg_match_gf() function.

Three details make or break this step:

Use calculation mode, not value mode. In each field of the Update Item action, switch the value to a calculation. In value mode GlobiFlow writes your formula into the field as literal text instead of running it.
Reference the variable as [(Variable) propera] inside the calculation (not <propera>, which is the syntax used elsewhere).
preg_match_gf needs a third argument — the capture-group index to return. Leaving it off throws ArgumentCountError: Too few arguments... 2 passed... 3 expected. Pass 1 to return the first capture group as a string.

Map these calculations onto your result fields:

Field	Calculation
ARV	`preg_match_gf('/"arv":\s*([0-9.]+)/', [(Variable) propera], 1)`
Summary	`preg_match_gf('/"summary_text":"([^"]+)"/', [(Variable) propera], 1)`
Confidence	`preg_match_gf('/"arv_confidence":"([^"]+)"/', [(Variable) propera], 1)`
Comp count	`preg_match_gf('/"comp_count":\s*([0-9]+)/', [(Variable) propera], 1)`
Price / sqft	`preg_match_gf('/"price_per_sqft":\s*([0-9.]+)/', [(Variable) propera], 1)`
Run link	`preg_match_gf('/"run_url":"([^"]+)"/', [(Variable) propera], 1)`
Normalized address	`preg_match_gf('/"normalized_address":"([^"]+)"/', [(Variable) propera], 1)`
Comps (full list)	`str_replace('\n', "\n", preg_match_gf('/"comps_text":"([^"]+)"/', [(Variable) propera], 1))`
Error	`preg_match_gf('/"error":"([^"]+)"/', [(Variable) propera], 1)`

The comps_text field is a ready-to-paste block with one comparable per paragraph (address, price, sqft, beds/baths, price per sqft, distance, sold date, verification status, condition, and a Zillow link), separated by blank lines. Map it to a large (multi-line) text field. The extra str_replace('\n', "\n", ...) wrapper turns the JSON line breaks into real line breaks in Podio; without it the whole list still lands, just on one line. (Prefer the structured per-comp data instead? Every comp is also in the response's comps array.)

Note on Zillow links: Podio only auto-links URLs that are written through its own text parser, which GlobiFlow's Update Item bypasses, so the Zillow links land as plain (copyable) text rather than clickable links. To make them clickable, write the field with ProcFu's podio_html_to_item_field script via a Remote HTTP Call.

Then set the status field to Done. On a failure response the error calculation fills in and arv comes back empty, so you can branch the status to Error. When the address is the problem, the message names the address Propera received, for example Propera could not find the address '5329 Jade Forrest Trl Raliegh'. Check the street number, city, state and ZIP on the lead and run it again., so whoever works the lead can see what to fix without leaving Podio.

Branch on the response's success value (true/false) with a GlobiFlow condition to decide whether to write the ARV or the error message. To validate a calculation in the editor, use simulate vars and paste a sample propera response — otherwise the variable is empty and the match returns FALSE, which is expected at edit time, not a real failure.

Request fields

Field	Value	Required
`address`	The lead's full address (street, city, state, ZIP). Any format works: Propera resolves it to a standard street, city, state and ZIP before running, and rejects it with `ADDRESS_NOT_FOUND` if it cannot.	Always
`property_type`	`sfh`, `condo`, `townhouse`, `manufactured`, or `land` (case-insensitive)	Always
`bedrooms`	Number of bedrooms	Residential
`bathrooms`	Number of bathrooms	Residential
`year_built`	Year the property was built	Residential
`sqft`	Living area for residential, or lot size for land	Always
`comp_radius`	Search radius in miles (residential up to 15, land up to 50)	Always
`lot_size_unit`	`sqft` or `acres`	Land only
`soft_errors`	`true`: every failure comes back as HTTP 200 with `success: false` so the flow keeps running (real code in `http_status`)	Recommended

Response fields

Field	Description
`success`	`true` on success, `false` on failure (branch on this)
`arv`	The after-repair value estimate
`arv_confidence`	Confidence in the ARV (high / medium / low)
`summary_text`	One-line summary for a notes field
`comp_count`	Number of comparables used
`price_per_sqft`	Average price per square foot
`run_url`	Link to the saved run in Propera
`normalized_address`	The address as Propera resolved it (street, city, state, ZIP). Write it back to the lead if you want the corrected version.
`comps_text`	Ready-to-paste plain-text list of every comp (one per paragraph, with verification status, condition, and Zillow links) for a single large text field
`comps`	Structured array of each comp (address, price, sqft, beds, baths, ppsf, distance, sold date, Zillow link)
`error`	On failure, a human-readable reason
`error_code`	On failure, a machine-readable code (see Troubleshooting)
`http_status`	On failure with `soft_errors` on, the HTTP code the failure would otherwise have carried (401, 402, 403, 422, 503)

Troubleshooting

error_code	What it means	Fix
`INSUFFICIENT_COMPS`	Not enough comps at that radius	Widen `comp_radius` (residential up to 15 mi, land up to 50 mi)
`NO_USABLE_COMPS`	Comps were found but none passed the filters	Widen `comp_radius` (residential up to 15 mi, land up to 50 mi)
`ADDRESS_NOT_FOUND`	Propera could not resolve the address it received. The `error` message names that address and lands in your Error field	Fix the street number, city, state or ZIP on the lead and run it again; for rural roads try an alternate name
`PLAN_NOT_ELIGIBLE`	Your plan doesn't include API access	Upgrade to Pro or Business
`UNAUTHORIZED`	The API key is missing, wrong, or revoked	Check the `X-API-Key` header
Flow stops at the HTTP call, Error field stays empty	GlobiFlow's log shows `Error: HTTP Response - 422 {...}` and the Update Item step never ran	Add `"soft_errors": "true"` to the POST body (Step 3)

Questions people ask

Do I need GlobiFlow, or will plain Podio work?

You need GlobiFlow. Podio on its own cannot make an outbound POST with a JSON body, which is what the Propera API requires. GlobiFlow's webhook action is what sends the request and receives the response back into the item.

Which Propera plans include API access?

Pro and Business. The GlobiFlow webhook authenticates with an API key from your account; a Starter key returns 403 on every call.

Why is my request body arriving with strange characters in it?

GlobiFlow URL-encodes double quotes in some contexts, which turns a valid JSON body into an invalid one and produces a 422. If the request looks correct in the flow editor but the API rejects it, check the raw body for encoded quote characters before assuming the payload is wrong.

Does each flow run use one of my monthly ARVs?

Yes. Every analysis consumes one AI ARV from your plan's monthly allowance. Once it is exhausted the API returns 402 until the allowance resets on your next billing cycle, so trigger the flow on a qualifying condition rather than on every item creation.

What comes back into the Podio item?

The ARV, the comparable sales used, and property links, written to whichever fields you map in the flow. If the address cannot be matched the API returns 422 with a message and nothing is written, so the item is left as it was rather than partially filled.

Ready to auto-underwrite your Podio pipeline?

Generate your API key and wire up GlobiFlow in minutes.

Get Started