How to Capture New Property Listing Intake from a Web Form Webhook into Monday

Receive a new-listing submission from your listing site over a webhook, let an Agent-mode Connector node normalize the messy address, price, and bedroom fields into a clean structure, map it to your Monday board columns, log the listing as an item, alert your team in Slack, and return the new item id to the caller.

What This Integration Does

Real estate intake forms are rarely tidy. One agent types "3br", another writes "3 Bedrooms", a price comes in as "$745,000" in one submission and "745000" in the next, and the address arrives as a single free-text line. This Spojit workflow accepts whatever your listing site or portal posts, uses an Agent-mode Connector node to read that loose payload and emit a consistent structure, then writes a clean record into a Monday board so your whole pipeline sees the same shape every time. Your team gets a Slack ping the moment a listing lands, and the form receives the new Monday item id back so it can show a confirmation or store a reference.

The run starts when an external HTTP POST hits the workflow's webhook URL. Spojit parses the JSON body into {{ input }}, the agent produces a normalized object, a Transform node maps that object onto your board's column ids, the monday connector creates the item, a slack message notifies the team, and a Response node returns the created item id synchronously to the form. Each submission is independent: re-posting the same form data creates a new item, so add dedup or a lookup step if your form can fire twice.

Prerequisites

A monday connection (API token) added under Connections, with create access to the board you want to log listings on.
A slack connection with permission to post to your listings channel, and the channel id or name you want to notify.
A signing connection for the webhook trigger (scheme Spojit or Custom with your own HMAC secret), so only your listing site can start runs.
Your Monday board id and the column ids you will write to (open the board, note the id, and map each field such as address, price, and beds to its column id).
The shape of the payload your listing site posts. If your site cannot post directly, it can call Spojit's webhook URL using its own outbound request, or you can pull from your portal's REST API via the http connector.

Step 1: Receive the submission with a Webhook trigger

Add a Trigger node and set its type to Webhook. Spojit gives you a unique URL to paste into your listing site or portal as the destination for new-listing submissions. Attach your signing connection so the request is verified by HMAC before any work runs. The trigger parses the posted JSON into {{ input }} (or { raw: "..." } if the body is not JSON) and immediately returns 202 with an executionId to acknowledge receipt. A typical raw submission looks like this:

{
  "address": "12 Banksia St Hawthorn VIC 3122",
  "price": "$745,000",
  "beds": "3br",
  "baths": "2",
  "agent": "sam@acme-realty.com",
  "notes": "Renovated kitchen, north-facing"
}

Step 2: Normalize the payload with an Agent-mode Connector node

Add a Connector node and switch it to Agent mode. This is where the agent reads the loose fields and returns a clean object. Give it a focused prompt that references the incoming data, and set a Response Schema so the output is forced into reliable JSON rather than prose. A prompt such as:

Normalize this property listing submission into the response schema.
Split the address into street, suburb, state, and postcode.
Convert price to an integer in dollars with no symbols or commas.
Convert beds and baths to integers. Submission: {{ input }}

Define the Response Schema with the exact keys you want downstream, for example street, suburb, state, postcode, price, beds, baths, and summary. Save the result to an output variable such as listing, so later steps read {{ listing.price }} and friends. Agent mode costs AI credits, so keep the prompt tight and the schema small.

Step 3: Map the clean object to board columns with a Transform node

Add a Transform node to shape the normalized listing into the structure the monday create-item call expects. Monday's create-item takes a columnValues object keyed by your board's column ids, so build exactly that. Read from {{ listing }} and emit something like:

{
  "title": "{{ listing.street }}, {{ listing.suburb }}",
  "columnValues": {
    "text_address": "{{ listing.street }}, {{ listing.suburb }} {{ listing.state }} {{ listing.postcode }}",
    "numbers_price": {{ listing.price }},
    "numbers_beds": {{ listing.beds }},
    "numbers_baths": {{ listing.baths }},
    "text_agent": "{{ input.agent }}"
  }
}

Replace each key (text_address, numbers_price, and so on) with the real column ids from your board. Keeping this mapping in a Transform node means schema changes on the board are a one-place edit. If you need string handling beyond templating, the text and json connectors (for example json-set or json-pick) can assemble the object too.

Step 4: Log the listing with the monday connector

Add a Connector node in Direct mode on the monday connector and pick the create-item tool. Map its inputs from the previous step: set boardId to your listings board id, name to {{ transform.title }}, optionally groupId to the group you want new listings to land in, and columnValues to {{ transform.columnValues }}. Direct mode is deterministic and uses no AI credits, which is what you want for a predictable single write. Save the output to a variable such as created. The created item id is then available at {{ created.create_item.id }}.

Step 5: Notify the team in Slack

Add a Connector node in Direct mode on the slack connector and choose send-message. Set the channel to your listings channel and compose a short message from the normalized data so the team sees the essentials without opening Monday:

New listing intake: {{ listing.street }}, {{ listing.suburb }}
Price: {{ listing.price }} | Beds: {{ listing.beds }} | Baths: {{ listing.baths }}
Logged to Monday item {{ created.create_item.id }} by {{ input.agent }}

If you would rather reach a teammate by email address than a channel id, run lookup-user-by-email first and send to the returned user. For a richer alert, you can also add the AI-written {{ listing.summary }} line so agents get the one-sentence pitch in the channel.

Step 6: Return the new item id with a Response node

Because the trigger is a synchronous webhook, finish with a Response node so the listing site receives confirmation rather than just the 202 acknowledgement. Return a small object the form can read, including the Monday item id:

{
  "status": "logged",
  "mondayItemId": "{{ created.create_item.id }}",
  "address": "{{ listing.street }}, {{ listing.suburb }}"
}

The form can now store that mondayItemId against the submission or display a confirmation to the agent who entered the listing.

Tips

Keep the Agent-mode Response Schema as the single source of truth for field names. When you add a field (say landSizeSqm), add it to the schema and the Transform mapping together.
Use Direct mode for the Monday write and the Slack post. Reserve Agent mode for the messy normalization only, so most steps stay deterministic and credit-free.
Send numeric Monday columns as actual numbers (no quotes around {{ listing.price }} in the Transform output) so they sort and filter correctly on the board.
If your listing site cannot post outbound, pull new submissions from your portal's REST API on a Schedule trigger using the http connector instead, then feed the same agent and Transform steps.

Common Pitfalls

Wrong column ids: Monday's create-item silently ignores values keyed by ids that do not exist on the board. Confirm every key in columnValues matches a real column id, not the column title.
Status or dropdown columns expect their own value format. For those, write the option label the way Monday expects rather than free text, or the cell stays blank.
Webhook replays: if your form retries on a slow response, you may get duplicate items. Enable opt-in dedup via an event-id header on the trigger, or look up the address before creating.
Skipping the signing connection leaves the webhook open to anyone who learns the URL. Always verify with an HMAC scheme.
Trusting raw input straight into Monday reintroduces the mess you are trying to remove. Always write from the normalized {{ listing }} object, not {{ input }}.

Testing

Point a single test submission at the webhook URL with a deliberately messy payload (mixed price formats, "3br" style beds, a one-line address) and watch the run in the execution history. Confirm the Agent-mode node output matches your Response Schema, the Transform output keys map to real column ids, a clean item appears on the board, the Slack message posts, and the Response returns the new item id. Once one submission is correct end to end, send a few varied payloads to be sure the normalization holds, then connect your live listing form.