maesn
Product insight

Every system, one common data model

Maesn normalizes responses, formats and structures across every ERP and accounting system, so you build against a single schema instead of dozens. Where a native endpoint falls short, Maesn fills the gap under the hood.

Three systems, one fieldaccount.currency
XerocurrencyCode: "EUR"
sevdeskcurrency: "EUR"
Lexware Officeeuro-only, no field
maesn normalizes
Common data model
{ "currency": "EUR" }
Trusted by winning software teams
HubSpotTipaltiPaywiseRallyQredNordhealthFindityFintoClockinProvetHeroHolviLanes & PlanesHubSpotTipaltiPaywiseRallyQredNordhealthFindityFintoClockinProvetHeroHolviLanes & Planes
The concept

What is a common data model

A Unified API exposes one standardized set of endpoints across many systems in the same category and normalizes each system's data into shared schemas. Instead of learning every ERP's data shapes, you implement a single code base and always receive consistent, normalized data, whichever system your customer runs.

Normalization happens at the level of the schema, not just the field name. Maesn aligns field names, data types, date and currency formats and the relationships between objects, so an invoice, its line items and its contact fit together the same way in every system. That is what separates a common data model from a plain field-by-field mapping: you build against one predictable structure once, instead of reconciling each system's quirks yourself every time you add another integration.

The problem

Every system models data differently

The same invoice looks different in every system: different field names, date formats, currency handling and object structures. Building and maintaining a separate mapping for each one is where integration projects stall.

Field names
currencyCodecurrency— missing
Date formats
2026-01-0101/01/2026…T00:00+02:00
Country codes
"Germany""DE""DEU"
One object
invoice+ lines+ contact = 3 calls
How Maesn handles it

Normalized, ISO-standardized and complete

Just a few examples. Maesn normalizes far more than this, across every field, object and system.

The same value, named three ways

Xero returns it as currencyCode, sevdesk as currency, and Lexware Office has no currency field at all because it only supports euro. Maesn returns one currency field, always with the right value.

Xero → currencyCodesevdesk → currencyLexware → euro-only"currency": "EUR"

One normalized schema

Responses, formats and structures are normalized across every system, so every integration you build behaves identically.

Background multi-calling

Where a native endpoint does not return everything, Maesn makes the extra calls under the hood and assembles one complete object.

ISO standards enforced

Country codes follow ISO 3166-1, currencies ISO 4217 and dates ISO 8601, validated on the way in and on the way out.

Automatic date conversion

Send a date or a full timestamp. Maesn converts it to what each system expects, adding midnight UTC or dropping the time as needed.

invoice.json
{
"object": "invoice",
"id": "inv_8842",
"contact": { "id": "cus_204", "name": "ACME GmbH" },
"currency": "EUR",
"issueDate": "2026-01-01",
"lines": [{ "description": "Consulting", "quantity": 4 }]
}
ISO 3166-1
Country codes
ISO 8601
Dates and timestamps
ISO 4217
Currency codes
Under the hood

Complete objects, assembled for you

Some systems never return a complete object from a single endpoint. To read one invoice you might have to call the invoice endpoint, then a separate endpoint for its line items, then another for the contact it belongs to, and stitch the three responses back together yourself.

Maesn does that work in the background. When a native endpoint falls short, Maesn makes the additional calls under the hood and assembles one complete object before it ever reaches your code. You request an invoice and you receive an invoice, its lines and its contact included, whichever system it came from. The multi-calling, the ordering of those calls and the reassembly all stay on Maesn's side, so your integration reads one object and moves on.

Native system, three calls
GET/invoices/inv_8842
GET/invoices/inv_8842/lines
GET/contacts/cus_204
maesn assembles
One complete object
{
  "object": "invoice",
  "id": "inv_8842",
  "lines": [ … ],
  "contact": { "name": "ACME GmbH" }
}
Why it matters

One model, less to maintain

Building it yourself
  • Map every system's data shapes by hand
  • Branch your logic for each system's quirks
  • Re-map whenever a system changes its API
  • Rebuild for every new system you add
With Maesn
  • Build against one schema
  • No per-system branching
  • Upstream changes absorbed for you
  • New systems included automatically

The common data model deliberately covers the fields and objects that every system shares. When a customer needs something outside it, you are not stuck. Customization handling reaches anything beyond the model: Authenticated Passthrough calls any endpoint in the system directly, and Raw Data gives full, unfiltered access to whatever the system returns. Nothing is locked away, so the model stays clean without limiting what you can build.

Common Data Model FAQ

Common questions

Field names, data types, date and currency formats and the relationships between objects, across every supported system, into one shared schema.

Build once on the Unified API.

See how the Common Data Model works for your integration, or dive into the technical reference.