Check the status on the portal
GET /property-v1/properties/{paId}/publication/{portal}
This is how you find out how the listing is doing on the other side: whether it's still online, what its public URL is, how many visits it had, and whether the portal logged any error.
This call uses up one call from the client's monthly quota on the portal, just like publishing.
If you only need the last known state, GET /properties/{paId} gives it to you without spending anything.
curl https://property-api.mapaprop.com/property-v1/properties/01M41AQNXYG4W4SEEEEPHEDNX4/publication/zonapropapi \
-H "Authorization: Bearer $TOKEN" \
-H "x-client-ref: cliente-42"
{
"paId": "01M41AQNXYG4W4SEEEEPHEDNX4",
"portal": "zonapropapi",
"remoteStatus": "unpublished",
"inSync": false,
"remote": {
"portalItemId": 60321762,
"url": "https://www.zonaprop.com.ar/propiedades/clasificado/-60321762.html",
"publicationState": "OFFLINE",
"processingState": "PROCESADO",
"onlineAt": "2026-10-03T17:14:06.000Z",
"offlineAt": "2026-10-03T04:00:00.000Z",
"createdAt": "2026-10-03T17:14:05.000Z",
"modifiedAt": "2026-10-03T17:14:28.000Z",
"visits": 0,
"errors": [],
"warnings": [],
"imagesStatus": [],
"exists": true,
"checkedAt": "2026-10-03T18:42:57.716Z"
},
"quota": { "remaining": 1443, "limit": 1500 }
}
The listing's URL
remote.url is where the published listing can be seen. It can't be built on your side: it carries
the portal's internal id (remote.portalItemId), which is different from the code you use to publish.
remote.url comes back as null if we don't have the portal's id yet, or if we can't build the URL
with certainty for the property's country. We don't build an approximate one: a link that leads
somewhere else is worse than no link.
The two reads: one free, one fresh
| What it returns | Quota | |
|---|---|---|
GET /properties/{paId} | the last state we already had, in published.{portal}.remote | free |
GET …/publication/{portal} (this page) | asks the portal right now | 1 call |
To decide between the two there's remote.checkedAt: it tells you when the stored data is from. If
that's good enough, there's no need to ask again.
If you go through your entire inventory checking property by property, you use up one call for each one. With 400 properties that's 400 calls from your client's monthly quota. Read the stored state first and only query what you need fresh.
remoteStatus and inSync
remoteStatus is the listing's status, and this call updates it with whatever the portal says.
| What the portal says | remoteStatus ends up as |
|---|---|
publicationState: ONLINE | published |
publicationState: OFFLINE | unpublished |
a PLAN (HOME_ZONA_DEMAND, SIMPLE…) with onlineAt and no offlineAt | published |
a PLAN with offlineAt | unpublished |
| an OPERATION status (reserved, sold, rented) | published — see below |
| the listing doesn't exist on the portal | unpublished |
| something we don't recognize and without dates | left untouched |
A listing with an operation status is still
published. If you marked the property as sold, the portal hides it — that's correct — but
the listing is there: it's ours and we set it up that way on purpose.
"remoteStatus": "published",
"remote": { "publicationState": "VENDIDO", "visible": false }
We say it this way because the opposite would push you to republish: if you read unpublished on a listing
that's perfectly fine, every retry of yours would try to publish it again. publicationState tells you
why it's not showing, with the portal's own wording.
publicationState isn't always a status: while the listing is online under a named plan, the
portal puts the PLAN there instead. When it's taken down it goes back to saying OFFLINE.
When that happens, we resolve the status from the dates (onlineAt / offlineAt), which is the record
the portal keeps of when it went up and when it came down.
inSync answers the question that matters: is the listing the way you left it?
inSync | What it means | What to do |
|---|---|---|
true | the portal matches what you expected | nothing |
false | it changed without you asking — it fell off, or the plan expired | publish it again if you want it back up |
null | the portal didn't give us enough to decide: a status we don't interpret and no onlineAt | look at the full remote and write to us with the reference |
We don't republish on our own. If the listing fell off, we tell you with
inSync: false and the decision is yours: maybe you no longer want it up.
The other remote fields
remote is whatever the portal answers, so its content changes depending on the portal. The only
fields present in both are portalItemId, url, exists and checkedAt; everything else depends
on what each one reports. Don't assume a field exists just because you saw it on the other portal.
| Zonaprop | Argenprop | |
|---|---|---|
| Status | publicationState + the dates (onlineAt / offlineAt) | publicationState too, with its own dictionary: VIGENTE · SUSPENDIDO · HISTORICO · RESERVADO · VENDIDO |
| Whether it's visible | — | visible — ⚠️ on a development it doesn't mean that, see below |
| Metrics | visits | points, the listing's own |
| Processing | processingState | not reported |
| Images and warnings | imagesStatus · errors · warnings | not reported |
What doesn't change is remoteStatus, the field above: we normalize that one ourselves to
published / unpublished / null precisely so you don't have to read each portal's own shape
to know whether the listing is up.
On an Argenprop development, visible: false is normal
A development that's published and visible on the site still comes back like this:
"remote": { "publicationState": "VIGENTE", "visible": false }
Measured against the portal: for Argenprop visible and publicationState are two separate axes, and
on a development —and its units— Visible comes back as false even though the listing is showing. We
transport that value as is, without interpreting it.
⇒ To know whether it's up, look at remoteStatus (or publicationState), not visible. On a
development, visible: false doesn't indicate any problem and there's nothing to fix.
The table below is Zonaprop's, which is the portal that reports the most:
| Field | What it is |
|---|---|
portalItemId | the id the portal gave the listing. It's what forms the URL. Present on both portals |
publicationState | ONLINE / OFFLINE, or the plan name while it's online. See the note above |
processingState | what processing stage this listing is in: ESPERANDO_PROCESAR (queued), EN_PROCESO (processing) or PROCESADO (done). It's what the portal says, uninterpreted — and the enum is theirs, so it can grow |
onlineAt · offlineAt | when it went up and when it came down |
createdAt · modifiedAt | on the portal's side, not yours |
visits | visits the portal logged. null if it doesn't report them |
errors · warnings | exactly as the portal sends them, untranslated |
imagesStatus | what the portal did with each image |
exists | false if the listing isn't on the portal |
checkedAt | when we asked |
errors can carry entries even when the publication went fine: they're notes the portal leaves on
its own. They go uninterpreted because the portal's own wording is more precise than any
translation of ours.
What processingState answers, and what it doesn't
There are three different questions and the field answers one:
| The question | The field |
|---|---|
| is the listing up? | remoteStatus (and publicationState with the dates, which is where it comes from) |
| what stage is this listing in? | processingState |
| can I write again yet? | 🔴 no field answers that. You answer it by retrying |
processingState doesn't factor into the publication verdict, and that's on purpose. On a development
the portal leaves PROCESADO before and after taking it down, so a status derived from that would say
"published" forever without ever failing. The verdict comes from the dates.
And PROCESADO doesn't mean "you can write now" on a development either.
On a large development the publication is processed asynchronously: the parent listing reaches
PROCESADO while the units are still queued, and the portal's write lock lives on the
entire development, not on the listing.
With 20 units, PROCESADO is reached in 3 minutes and the portal keeps rejecting writes with
409 portal_processing for almost 6 more minutes.
⇒ If you're coming from a 409, the way forward is still wait and retry. Checking the status tells you
what stage the listing you asked about is in; it doesn't tell you when the portal is going to accept the next
write, and we don't have that data: the portal doesn't send it.
It's the same field with the same name on a listing and on a development, so whatever reading logic you write works for both — Publishing and unpublishing a development.
And before using it, look at the cost: asking uses up one call from your client's quota; waiting is
free. For the processing window, backing off on the 409 is still the recommended approach — this
is the alternative for those who'd rather know than wait.
Response codes
| Code | What happened | What to do |
|---|---|---|
200 | the listing's status | — |
403 | your token doesn't have the {portal}:publish scope | write to us to enable it |
404 | that property isn't in your inventory | check the paId and the x-client-ref |
409 | the account isn't connected to the portal | request a connection link |
501 | we still can't check the status on that portal | the portal comes back in portal |
403 | that ad does not appear in your client's account on the portal (listing_not_found_or_not_yours) | it may not have been published, it may have been taken down, or it may be under another account. The portal answers the same in all three cases, so we do not claim which one it is |
409 | the portal no longer recognises your client's account (portal_account_unlinked) | connect it again: request a link |
409 | the portal has the account disabled or blocked (portal_account_blocked) | write to us with the reference: the link with the portal is managed by us |
502 | we couldn't ask the portal | try again; we don't change anything on your side |
None of those three changes the status we have stored. A rejection about the state of the
account — or about an ad that does not appear — says nothing about whether the ad is published, so
we leave it as it was. It is the same rule as the 502: we do not claim what we could not measure.
A 501 doesn't mean the portal doesn't exist: you might be able to publish on it perfectly fine and
what's missing is just this check. Today it's available on Zonaprop.
Related
- Publishing on portals — the three methods of the same endpoint
PUTpublish ·DELETEunpublishGET /properties/{paId}— the read that doesn't cost quota