Urbaneta Now Has a Public API — Here's What You Can Do With It

A few weeks ago, a property manager asked me something that stuck with me. "We use Urbaneta for our buildings, but our accounting software is custom. Can we pull the invoice data automatically instead of exporting CSVs every month?"

My answer then was "not yet." My answer today is different.

Urbaneta now has a public API. It's live, documented, and ready for integrations. If you're a developer, a property management company with in-house tech, or just someone who wants to stop copying data between systems, this is for you.

What actually shipped

Three things went live together, and they work as a set:

1. API Documentation — a public reference at /api-docs that tells you exactly what endpoints exist, what they accept, and what they return.
2. API Keys — scoped tokens you generate in your admin panel to authenticate requests.
3. Webhooks — real-time notifications that push events to your own server instead of making you poll for changes.

Let's walk through each one.

API Documentation: the map

The first thing you need when building against any API is clear documentation. We've put ours at /api-docs on the main Urbaneta domain. No login required — it's public.

It covers:

• Authentication: How to include your API key in the Authorization: Bearer header.
• Buildings, apartments, and residents: CRUD operations for the core entities.
• Invoices and meter readings: The data that property managers actually care about.
• Webhooks subscription: How to register and manage webhook endpoints.
• Error codes: What 400, 401, 403, and 429 mean in practice, plus rate-limiting behavior.

The docs are generated from the actual API source, so they don't drift out of date. If an endpoint changes, the docs update with it.

API Keys: scoped, not all-powerful

Here's something I insisted on during the design: API keys should be scoped. You shouldn't hand a third-party integration a key that can delete buildings just because they need to read invoice data.

In your admin panel, under Integrations → API Keys, you can create keys with specific permissions:

• read:buildings — list buildings and apartments
• read:invoices — fetch invoice data
• write:invoices — create or update invoices
• read:residents — resident directory access
• webhooks:manage — subscribe and manage webhook endpoints

You can create multiple keys for different integrations. If a vendor's key leaks, you revoke just that one. No need to rotate everything.

The keys are prefixed with nmv_ so they're easy to spot in logs and code reviews. They use SHA-256 hashing on our side, so even a database breach doesn't expose the actual tokens.

Your first request in 30 seconds

Reading docs is fine. Running your first request is better. Here's a real curl call that lists your buildings — copy it, swap in your API key, and run it right now:

curl https://urbaneta.com/api/v1/buildings \
  -H "Authorization: Bearer nmv_YOUR_API_KEY"

You'll get back a JSON array of every building in your account, with apartment counts, resident counts, and address details. No pagination to worry about for accounts under 100 buildings.

Want to pull a specific month's invoices instead? Same pattern, different endpoint:

curl "https://urbaneta.com/api/v1/invoices?created_after=2026-07-01" \
  -H "Authorization: Bearer nmv_YOUR_API_KEY"

That one line replaces the monthly CSV export I mentioned at the top of this article. Run it from a cron job, pipe the JSON into your accounting system, and the manual step is gone for good.

Webhooks: stop polling, start reacting

This is the one I'm personally most excited about. Polling is wasteful. If you check every 5 minutes whether a new invoice was created, you're making 288 requests per day for data that maybe changed twice.

With webhooks, Urbaneta pushes events to your URL as they happen:

• invoice.created
• invoice.paid
• resident.invited
• maintenance_request.updated
• meter_reading.submitted

You subscribe to the events you care about in Integrations → Webhooks. Urbaneta sends a POST request to your endpoint with a signed payload. You verify the signature, process the event, and you're done.

We include a retry mechanism: if your endpoint returns a non-2xx status or times out, we retry with exponential backoff for up to 24 hours. Delivery is at-least-once, so your endpoint should be idempotent. We also include an X-Urbaneta-Event-ID header so you can deduplicate if needed.

A practical example

Let's say you run a property management company with a dozen buildings. You want to:

1. Pull all invoices created this month into your accounting system.
2. Mark an invoice as paid when the bank transfer clears.
3. Notify your maintenance team when a resident submits a meter reading photo.

Before the API, this was manual CSV exports, spreadsheet matching, and phone calls. Now it's:

• A cron job that calls GET /api/v1/invoices?created_after=2026-07-01 once a day.
• A webhook handler for invoice.paid that updates your ledger automatically.
• A webhook handler for meter_reading.submitted that posts to your internal Slack channel.

The whole integration might take a developer a day or two. The time savings start immediately.

What this means for property managers

If you're not a developer, you might be thinking: "this is nice, but I don't write code." Fair. Here's why it still matters:

Your vendors can integrate. If you use an accounting tool, a maintenance platform, or a resident communication app, you can ask them to build an Urbaneta integration. The API and webhooks give them everything they need. You get automatic data sync without touching a line of code.

White-label portals stay independent. API keys are scoped per tenant. If you run a white-label property management portal under your own domain, your API keys only see your data. There's no cross-tenant leakage.

What's next

The current API covers the core property management flows: buildings, residents, invoices, meter readings, maintenance, and payments. We're expanding it based on what integrators actually ask for.

If you're building something and need an endpoint that doesn't exist yet, let us know. The API is designed to grow — we prefer shipping a small, solid surface and adding to it over building a massive spec that nobody uses.

Getting started

1. Open /api-docs in your browser. Read the authentication section.
2. Go to your admin panel → Integrations → API Keys and create a test key.
3. Make your first request: GET /api/v1/buildings with your key in the header.
4. If you need real-time events, head to Integrations → Webhooks and register your endpoint.

The documentation includes copy-pasteable curl examples for every endpoint. You don't need to guess the payload shape.

A year ago, someone told me property management software should "just work" without integrations. I used to believe that. Now I think the opposite: the best property management platform is the one that connects to everything else you already use.

That's what we're building.

Want to try the API yourself? You can create a free Urbaneta account and generate an API key in under two minutes. No setup fee, no credit card — just a test building and real endpoints to call.