.png)
Mews Integration Guide
Integrate Mews with enterprise systems through its REST APIs, selected webhook notifications, incremental retrieval, and authenticated JSON requests.
Mews integration options at a glance
Mews provides REST-style Connector API and Open API capabilities for reservations, customers, resources, services, payments, invoices, and related hospitality data. Approved integrations can authenticate with client tokens, access tokens, enterprise identifiers, or applicable OAuth-based authorization. Mews also supports webhook-style notifications for selected event types, while collection endpoints support pagination and incremental retrieval using filters, cursors, or continuation markers. Martini can consume these APIs, receive supported notifications, orchestrate scheduled reconciliation workflows, map Mews objects into enterprise models, and apply retries, checkpointing, validation, and idempotent writes. Direct database access, SOAP, GraphQL, and a universal attachment API were not confirmed.
| Integration point | Supported by Mews? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Mews Connector API and Open API resources support reservations, customers, resources, services, payments, accounting data, and selected create or update operations. Collection requests can use filters and incremental retrieval. | Martini can consume Mews REST endpoints, send authenticated JSON requests, transform responses, apply business rules, and expose normalized APIs to downstream applications. |
| Webhooks / outbound callbacks | Limited | Mews supports webhook-style notifications for selected event types. Coverage is event-specific and should not be assumed for every object or state transition. | Martini can receive supported Mews notifications through a workflow trigger or exposed REST API, validate the payload, deduplicate events, and invoke downstream workflows. |
| Bulk / incremental retrieval | Limited | Mews collection endpoints support pagination and incremental synchronization using date or modification filters, cursors, continuation tokens, or GetAll-style methods where provided. | Martini can loop through pages, persist a cursor or timestamp checkpoint, use overlap windows, and delay checkpoint advancement until downstream writes succeed. |
| Authentication | Yes | Mews integrations use application and enterprise credentials, commonly including a client token, access token, and enterprise identifier. OAuth-based authorization may apply to Open API or marketplace integrations. | Martini can store credentials as environment-managed secrets and inject them into request bodies or authentication configuration without embedding them in workflows or logs. |
| GraphQL APIs | Not confirmed | No official Mews GraphQL API was confirmed for this research. New integrations should use the documented REST APIs instead. | Martini supports GraphQL generally, but a Mews integration should not use GraphQL unless Mews separately documents and enables such an endpoint. |
| SOAP APIs | No | Mews integration documentation is centered on REST APIs; no official Mews SOAP API was confirmed. | Martini can consume SOAP services generally, but SOAP should not be selected for Mews without a separately documented Mews service. |
| File / attachment APIs | Not confirmed | No general-purpose Mews attachment or binary-file API was confirmed for standard Connector API integration. | Martini can process files from supported enterprise endpoints when separately available, but should not assume that Mews reservation documents or guest files are accessible through a universal attachment endpoint. |
| Database / analytics access | No | Mews does not expose direct database access for normal integrations. Reporting or analytics data should use Mews APIs or a separately provisioned reporting or export mechanism. | Martini can connect to enterprise databases when appropriate, but it should consume Mews APIs rather than connect to the underlying Mews database. |
How Mews exposes data and business events
Mews REST APIs
Mews provides REST-style Connector API and Open API resources for hospitality, reservation, customer, operational, and financial data. Depending on the API product and permissions, integrations can retrieve and update selected objects such as Reservations, Customers, Resources, Services, Payments, Invoices, and Accounting items.
Martini implementation pattern
Martini implementation pattern: Martini workflows send authenticated JSON requests to the applicable Mews endpoint, handle pagination and incremental filters, transform responses into canonical models, apply business rules, and write results to target applications or expose them through internal APIs.
Implementation sequence
Mews Webhook Notifications
Mews supports webhook-style notifications for selected event types. Notifications do not represent every possible Mews object or state transition, so event coverage and subscription configuration must be verified for the relevant API product and enterprise.
Martini implementation pattern
Martini implementation pattern: Martini receives the supported notification through a workflow start trigger or exposed REST API, validates and deduplicates the event, retrieves the current Mews resource when the notification is incomplete, and invokes downstream processing. Scheduled reconciliation covers changes outside notification coverage.
Implementation sequence
Mews Incremental Retrieval
Mews collection endpoints support pagination and incremental retrieval using date or modification-time filters, cursors, continuation tokens, or GetAll-style methods where provided. This supports scheduled reconciliation and initial data loads, but is not a universal asynchronous bulk export service.
Martini implementation pattern
Martini implementation pattern: A scheduler-triggered workflow loads the last successful cursor or timestamp, requests each page, processes all downstream writes, and advances the checkpoint only after the complete run succeeds. An overlap window and idempotent upserts help handle late-arriving updates.
Implementation sequence
Mews Authentication
Mews API access is controlled through application and enterprise credentials. Connector API requests commonly include a client token and access token in the JSON request body together with an enterprise identifier, while OAuth-based authorization may apply to Open API or marketplace-style integrations.
Martini implementation pattern
Martini implementation pattern: Martini stores client tokens, access tokens, enterprise identifiers, and applicable OAuth credentials in environment-managed secrets. Workflows inject them according to the selected Mews API authentication model and keep credentials out of workflow definitions, public APIs, and logs.
Implementation sequence
Common Mews integration patterns
Pattern 1: Sync reservations to guest engagement systems
When to use this pattern
Use this pattern when guest profiles, stay history, and reservation activity must be available in a customer engagement platform. Scheduled incremental retrieval provides reconciliation, while selected Mews notifications can reduce latency for supported events.
Integration direction
Example Mapping
| Mews Field | Canonical Field | Target Field |
|---|---|---|
| Reservation.id | stay.sourceId | Salesforce reservation reference |
| Reservation.startUtc | stay.checkInDate | Salesforce check-in date |
| Reservation.endUtc | stay.checkOutDate | Salesforce check-out date |
| Customer.id | guest.sourceId | Salesforce external guest ID |
Martini implementation pattern
Martini receives a selected event or starts on a schedule, retrieves the Reservation and related Customer data, and maps it into a canonical guest and stay model. Business rules enforce consent, property routing, and deduplication before Salesforce create-or-update operations. Retries handle transient failures, while stable Mews identifiers prevent duplicate guest or stay activity.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- error handling
Pattern 2: Reconcile Mews financial data
When to use this pattern
Use this pattern when finance teams need Invoices, Payments, Accounting items, and reservation context in a finance application. It is suited to scheduled processing with reconciliation controls rather than assuming that every financial change arrives as a webhook.
Integration direction
Example Mapping
| Mews Field | Canonical Field | Target Field |
|---|---|---|
| Invoice.id | invoice.sourceId | NetSuite external ID |
| Payment.amount | payment.amount | NetSuite payment amount |
| Accounting item.tax | line.taxAmount | NetSuite tax amount |
| Reservation.id | stay.sourceReservationId | NetSuite reservation reference |
Martini implementation pattern
A scheduled Martini workflow retrieves changed financial objects with the required permissions, follows all pages, and enriches them with related Reservation or Customer context. It validates accounting classifications, applies idempotent upserts and reconciliation rules, and writes a checkpoint only after target transactions are accepted. Authorization failures and permanent validation errors are separated from retryable throttling or timeout failures.
Martini capabilities used
- workflows
- API consumption
- pagination handling
- data mapping
- validation
- retries
- checkpoint management
Pattern 3: Route reservation data to distribution platforms
When to use this pattern
Use this pattern when a property needs reservation, resource, service, or availability-related data exchanged with a channel-management or distribution platform such as SiteMinder. The exact bidirectional operations must be verified for the selected products and permissions.
Integration direction
Example Mapping
| Mews Field | Canonical Field | Target Field |
|---|---|---|
| Reservation.status | booking.status | Mews reservation status |
| Resource.id | inventory.resourceId | Mews resource identifier |
| Service.id | booking.serviceCode | Mews service identifier |
| Reservation.startUtc | booking.arrivalDate | Distribution booking arrival date |
Martini implementation pattern
Martini receives or polls authorized distribution updates, resolves the Enterprise and property context, maps external booking data to Mews Reservations, Resources, and Services, and applies conflict and status rules before writing. A separate outbound workflow can publish Mews changes to the distribution platform. Correlation identifiers, retries, and reconciliation protect against duplicate or out-of-order updates.
Martini capabilities used
- bidirectional workflows
- API consumption
- data mapping
- routing rules
- business rules
- idempotency
- error handling
Pattern 4: Process selected Mews operational events
When to use this pattern
Use this pattern when reservation changes or other supported Mews notifications should initiate service, support, or operational actions. Because webhook coverage is selective, scheduled reconciliation should remain available for events outside the notification model.
Integration direction
Example Mapping
| Mews Field | Canonical Field | Target Field |
|---|---|---|
| Reservation.id | case.stayReference | Zendesk reservation reference |
| Reservation.status | case.bookingStatus | Zendesk ticket field |
| Customer.email | guest.contactEmail | Zendesk requester email |
| Enterprise.id | property.sourceEnterpriseId | Zendesk property field |
Martini implementation pattern
Martini receives a supported Mews notification, validates its signature or request context where applicable, checks for duplicate processing, and retrieves current Reservation and Customer details when needed. It applies property and support-routing rules before creating or updating Zendesk context. Failed downstream writes are retried safely, and scheduled reconciliation detects missed notifications.
Martini capabilities used
- workflow triggers
- API exposure
- API consumption
- data mapping
- validation
- deduplication
- monitoring
Applications commonly integrated with Mews
Mews data can be routed to adjacent hospitality, finance, customer engagement, support, revenue, and payment applications. The exact objects, permissions, and direction depend on the Mews API product, enterprise configuration, and the selected application. Martini can provide the orchestration, mapping, validation, and reconciliation layer without requiring a dedicated Mews connector.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize guest profiles, reservation activity, stay history, and customer engagement data. | Mews → Martini → Salesforce | A scheduled workflow or selected Mews notification starts the process. Martini retrieves related Reservations and Customers, applies consent and deduplication rules, maps the result to Salesforce objects, and performs idempotent create-or-update operations. |
| Oracle NetSuite | Transfer Invoices, Payments, Accounting items, taxes, and reconciliation data into finance operations. | Mews → Martini → Oracle NetSuite | Martini retrieves financial objects and their reservation context through the Mews REST API, transforms hospitality accounting data into the NetSuite model, validates required fields, and retries transient failures while preserving source identifiers. |
| Xero | Send selected financial transactions and settlement data to accounting workflows for hospitality organizations using Xero. | Mews → Martini → Xero | A scheduled Martini workflow retrieves changed Payments, Invoices, and Accounting items, applies reconciliation and duplicate-prevention rules, maps the data to Xero requests, and records processing status for later review. |
| Zendesk | Provide support agents with reservation and customer context for guest requests and service cases. | Mews → Martini → Zendesk | Martini receives a selected Mews notification or detects a change during reconciliation, hydrates the associated Customer and Reservation, and creates or updates Zendesk context after validating the guest and property identifiers. |
| SiteMinder | Coordinate reservation and distribution data between the PMS and hotel distribution or channel-management operations. | SiteMinder → Martini → Mews | Martini polls or receives authorized updates from the selected distribution platform, maps channel data to Mews Resources, Services, and Reservations, applies property-routing rules, and uses controlled retries for bidirectional updates. |
| Duetto | Provide reservation, occupancy, rate, and revenue-related data for revenue-management workflows. | Mews → Martini → Duetto | A scheduled workflow retrieves the relevant Mews reservation and operational data, applies enterprise and property-level routing, transforms the payload into the Duetto model, and stores checkpoints so subsequent runs process only the required changes. |
| Stripe | Coordinate payment-related workflows where Stripe is used alongside Mews or an external payment process. | Mews → Martini → Stripe | Martini retrieves authorized Payment data, preserves Mews identifiers, applies payment-state and reconciliation rules, and routes approved updates between Mews and Stripe according to the configured payment responsibility. |
How to build a Mews integration in Martini
Objective
Establish access to the applicable Mews Connector API or Open API product for each enterprise and environment.
Instructions in Martini
- Confirm the Mews API product, enterprise scope, permissions, and supported objects
- Store client tokens, access tokens, enterprise identifiers, and applicable OAuth credentials in Martini environment secrets
- Keep development, test, and production credentials separate where provisioning permits
- Do not expose credentials through public APIs, workflow definitions, or logs
Objective
Select an event-driven or scheduled trigger based on the Mews object and event coverage required by the integration.
Instructions in Martini
- Use supported Mews webhook-style notifications for selected low-latency events
- Use a scheduler for incremental retrieval, reconciliation, and initial loads
- Combine notifications with scheduled reconciliation when event coverage is incomplete
- Prevent overlapping synchronization runs where they could exceed Mews limits
Objective
Call the required Mews REST resources and obtain complete object sets with their related context.
Instructions in Martini
- Send authenticated JSON requests to the applicable Mews endpoint
- Treat collection responses as paginated unless the endpoint documentation states otherwise
- Follow cursors, continuation tokens, filters, or GetAll-style methods where provided
- Retrieve related Customers, Resources, Services, Payments, or Accounting items when the target model requires them
Objective
Coordinate the end-to-end process from notification or retrieval through target-system delivery and checkpointing.
Instructions in Martini
- Route each Enterprise and property context to the correct credentials and target systems
- Separate transport, transformation, business-rule, and persistence stages
- Persist cursors, timestamps, event identifiers, and processing outcomes
- Advance synchronization checkpoints only after downstream writes complete successfully
Objective
Convert Mews schemas into canonical and target-specific data models without coupling all logic to transport details.
Instructions in Martini
- Map actual Mews objects such as Reservations, Customers, Payments, and Invoices to canonical models
- Normalize dates, statuses, identifiers, amounts, and property context
- Preserve Mews source identifiers and timestamps for traceability
- Handle optional fields and unknown values without assuming all API products expose identical schemas
Objective
Apply validation, routing, privacy, deduplication, and financial controls before writing to target systems.
Instructions in Martini
- Validate required fields, identifiers, enum values, and Enterprise context
- Apply consent and data-minimization rules to Customer and reservation data
- Use stable Mews identifiers for idempotent create-or-update operations
- Separate permanent validation or authorization failures from retryable transient failures
Common Mews data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Enterprise | Represents the Mews customer organization or property group and provides context for credentials, routing, and property-level processing. | Salesforce, Oracle NetSuite, Xero, SiteMinder, Duetto | Martini carries the Enterprise identifier through workflows, selects the correct environment configuration, and prevents identifiers from different enterprises being treated as interchangeable. |
| Reservation | Represents a guest booking with stay dates, status, services, and related customer information. | Salesforce, SiteMinder, Zendesk, Duetto | Martini retrieves Reservations incrementally or from selected notifications, hydrates related objects when required, maps status and dates, and upserts using the stable Mews identifier. |
| Customer | Represents a guest or other customer profile associated with reservations and transactions. | Salesforce, Zendesk, marketing or guest-engagement applications | Martini applies field validation, consent and minimization rules, deduplicates by stable identifiers and approved matching fields, and routes only the required personal data. |
| Resource | Represents a bookable or operational resource such as a room or space. | SiteMinder, Duetto, operational applications | Martini preserves resource and property context, maps resource identifiers to target systems, and applies routing rules for multi-property deployments. |
| Service | Represents a hotel service or offering such as accommodation, breakfast, parking, or another chargeable service. | SiteMinder, Oracle NetSuite, Xero, operational applications | Martini maps service codes and descriptions, validates availability and financial classifications, and links service data to Reservations or Accounting items where required. |
| Payment | Represents a payment or payment-related transaction associated with a reservation or customer. | Oracle NetSuite, Xero, Stripe, reconciliation stores | Martini retrieves authorized Payment data, preserves source identifiers and timestamps, applies status and duplicate checks, and routes financial data without logging complete sensitive details. |
Authentication and security considerations
Credential models
Mews integrations commonly use a client token, access token, and Enterprise identifier. OAuth-based authorization may apply to Open API or marketplace-style integrations, depending on the registration model.
Martini security practices
- Store Mews credentials in Martini environment-managed secrets.
- Use separate credentials for development, testing, and production where available.
- Do not expose access tokens through public APIs, workflow definitions, or logs.
- Restrict access to Customer, Reservation, Payment, and financial data according to enterprise policies.
- Minimize copied personal and payment-related data and apply suitable retention and encryption controls.
Operational considerations for Mews integrations
Pagination and checkpoints
Treat Mews collections as paginated and persist a cursor, timestamp, or other supported incremental marker. Advance the checkpoint only after all pages and downstream writes complete successfully.
Rate limits and retries
Confirm current limits for the relevant Mews API product. Use controlled exponential backoff for throttling, timeouts, and temporary server errors, while avoiding retries for permanent validation or authorization failures.
Idempotency and event coverage
Webhook processing and scheduled polling can overlap. Use stable Mews identifiers, event tracking where available, and idempotent writes. Because notifications cover selected events, retain scheduled reconciliation for missed or unsupported changes.
Schema and property context
Keep transformations separate from transport logic, validate required fields and enum values, and monitor Mews API changes. Model Enterprise and property context explicitly because identifiers and permissions may vary across property groups.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini coordinates Mews API calls, selected notifications, pagination, related-object retrieval, target writes, and reconciliation in maintainable workflows. This avoids scattering authentication, checkpointing, and retry logic across independent scripts.
Reusable integration logic
Mappings, validation, routing, business rules, and error handling can be reused across Salesforce, finance, support, distribution, and revenue workflows while preserving Mews identifiers and enterprise context.
Controlled APIs and operations
Martini can expose normalized APIs to downstream applications, keep Mews credentials in environment configuration, and provide operational visibility into failures, retries, and workflow outcomes.
- Support event-driven and scheduled integration patterns.
- Separate transport, transformation, and business logic.
- Apply idempotency and reconciliation consistently.
- Handle multi-property routing and API-specific schemas.
Frequently asked questions
Mews can be integrated through its REST-style Connector API and Open API, authenticated application and enterprise credentials, selected webhook-style notifications, and paginated or incremental collection retrieval. Enterprise workflows typically use scheduled synchronization, event processing, or both, with reservations, customers, resources, services, payments, invoices, and accounting data mapped into downstream systems.
Yes. Martini can integrate with Mews by consuming its documented REST APIs, receiving supported Mews webhook notifications, running scheduled synchronization workflows, mapping Mews objects, and exposing normalized APIs to other applications. No native Martini Mews connector was verified in the supplied research.
No. A dedicated Mews connector is not required. Martini can use Mews native REST APIs, supported webhook notifications, authentication methods, and incremental retrieval mechanisms through workflows, API consumption, mappings, validation, and error handling.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Mews with Martini. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from Mews, cloud infrastructure, or other third-party systems based on subscriptions, usage, and deployment model.
New implementations should generally use the documented Mews REST APIs, selecting the Connector API or Open API according to the integration and authorization model. Webhook-style notifications can be used for selected events, while scheduled paginated or incremental retrieval should provide reconciliation and coverage for changes that are not notified.
Mews supports webhook-style notifications for selected event types, but coverage is not universal. No official Mews GraphQL or SOAP API was confirmed in the research. The documented integration approach is based on Mews REST APIs.
Martini can combine supported notifications with scheduled reconciliation. Stable Mews identifiers, event tracking, idempotent upserts, overlap windows, pagination checkpoints, and controlled retries help prevent duplicates and recover from missed events. Checkpoints should advance only after downstream writes succeed.
Yes. Martini can expose a controlled REST API that presents normalized Mews data to internal applications while workflows consume the Mews REST API behind it. The façade can centralize authentication, property routing, field mapping, validation, business rules, and protection of Mews credentials.
Related Martini documentation
Workflows
Integrate Mews with Martini
Use Martini to connect Mews REST APIs and supported event notifications with your hospitality, finance, customer, distribution, and operational systems through maintainable workflows and controlled APIs.