Ellipse Gradient for Header

Accela Integration Guide

Connect Accela Civic Platform with enterprise applications through REST APIs, OAuth 2.0, configurable event notifications, document operations, and scheduled synchronization.

Accela integration options at a glance

Accela Civic Platform’s primary integration mechanism is its REST API, which exposes resources such as Records, Inspections, Contacts, Addresses, Parcels, and Documents. Accela deployments may also provide configurable event notifications or outbound callbacks for selected scenarios, but universal webhook coverage is not confirmed. OAuth 2.0 application authentication, tenant and agency context, pagination, and incremental synchronization are important implementation concerns. Martini can consume Accela APIs from workflows, receive supported callbacks, map and transform data, transfer documents, expose normalized APIs, and coordinate scheduled, restartable synchronization with secure secrets and operational controls.

Integration pointSupported by Accela?Common use casesHow Martini supports it
REST APIsYesAccela’s primary application-integration interface supports reading and updating Records, Inspections, Contacts, Addresses, Parcels, Documents, and related Civic Platform resources.Martini can consume Accela REST endpoints from workflows, paginate through collections, transform responses, apply business rules, and call downstream APIs.
Webhooks and outbound callbacksLimitedSome Civic Platform deployments may expose configurable event notifications, outbound callbacks, or HTTP-based integration behavior for selected events.Martini can expose an API or receive supported callback requests through a webhook-triggered workflow, while scheduled reconciliation covers missed or unavailable events.
File and attachment APIsYesDocument-related REST resources can support retrieval or upload of files and metadata associated with Records and other transactions, subject to API version and agency configuration.Martini can retrieve or upload content, transform metadata, transfer files to repositories, and maintain source-to-destination correlation identifiers.
AuthenticationYesAccela applications generally use OAuth 2.0-style application authentication with client credentials, access tokens, permissions, and tenant or agency context.Martini can store client credentials and environment-specific parameters securely, acquire tokens, refresh them as required, and distinguish authentication from authorization failures.
Pagination and incremental synchronizationYesCollection retrieval and recurring synchronization require pagination and, where available, modification timestamps, status filters, or other stable incremental criteria.Martini workflows can iterate through pages, persist checkpoints, bound execution size, and resume processing after failures.
Bulk, asynchronous, and batch APIsNot confirmedA general-purpose bulk or asynchronous API covering all Accela resources was not confirmed. Resource-specific batch behavior must be verified before use.Martini can implement bounded, paginated, scheduled processing with checkpoints and retry handling instead of assuming bulk semantics.
SOAP APIsLegacyOlder Civic Platform deployments or agency-specific implementations may expose legacy services, but no current SOAP interface was confirmed as the recommended approach.Martini can consume SOAP services when a target deployment explicitly documents them, but Accela REST APIs should be evaluated first.
Database accessNoDirect access to the underlying Civic Platform database should not be assumed for application integration.Martini should use supported Accela APIs or separately documented reporting interfaces rather than direct database connectivity.

How Accela exposes data and business events

Accela REST APIs

Accela Civic Platform’s primary documented integration mechanism is its REST API. The API provides access to resources including Records, Inspections, Contacts, Addresses, Parcels, and Documents, with exact availability and fields dependent on agency configuration and API version.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates with OAuth 2.0, retrieves the required Accela resource, follows pagination, resolves related resources, maps the response to a canonical or downstream model, and writes the result to another API or system.

Implementation sequence

Authenticate the Martini workflow with the configured Accela application
Retrieve the required Accela resource and its page of results
Follow pagination until the selected synchronization scope is complete
Resolve related Contacts, Addresses, Parcels, Inspections, or Documents
Map Accela fields to the canonical and target data models
Apply validation, routing, and idempotency rules before writing the result

Accela event notifications and callbacks

Accela Civic Platform supports configurable event-driven integration capabilities, but a universal webhook for all resource changes was not confirmed. Callback availability, event types, and delivery behavior must be verified for the target agency deployment.

Martini implementation pattern

Martini implementation pattern: expose a controlled API endpoint or webhook-triggered workflow for the supported callback, validate the request, retrieve the current Accela resource when necessary, and use scheduled reconciliation when event coverage is incomplete.

Implementation sequence

Receive the supported Accela callback or event notification
Authenticate and validate the incoming request
Extract the affected resource identifier and event context
Retrieve the current Accela resource when the notification is not complete
Map and process the resource idempotently
Record the event outcome and reconcile missed changes on schedule

Accela document and attachment APIs

Accela REST resources include document-related operations for files associated with Records and other transactions. Upload, download, metadata, content, permissions, and file limits depend on the target API version and agency configuration.

Martini implementation pattern

Martini implementation pattern: retrieve Document metadata and content where permitted, validate content and correlation information, transfer the file to a repository or downstream application, and record the source and destination identifiers.

Implementation sequence

Retrieve the Accela Document metadata and available content
Validate file type, size, version, and source Record identifiers
Transform metadata to the destination document model
Transfer the file to the target repository or application
Persist the Accela-to-destination correlation key
Retry transient transfer failures without duplicating completed uploads

Accela scheduled synchronization

When event delivery is unavailable or incomplete, Accela REST polling can provide a controlled synchronization approach using pagination, incremental criteria where available, and maintained checkpoints.

Martini implementation pattern

Martini implementation pattern: a scheduler starts a bounded workflow, reads the last successful checkpoint, queries changed Accela resources, processes pages with stable correlation keys, and advances the checkpoint only after successful handling.

Implementation sequence

Start the workflow on a controlled schedule
Load the last successful synchronization checkpoint
Query Accela using supported incremental criteria and pagination
Process each page with bounded concurrency and idempotent writes
Persist the checkpoint after the required work succeeds
Route failures for retry and perform periodic reconciliation

Common Accela integration patterns

Pattern 1: Sync Accela Records to Salesforce

When to use this pattern

Use this pattern when constituent, applicant, or account-facing teams need current permit and licensing information in Salesforce. The flow should resolve related Accela Contacts and Addresses and use stable identifiers to avoid creating duplicate Salesforce objects.

Integration direction
Accela
Martini
Salesforce
Example Mapping
Accela FieldCanonical FieldTarget Field
Record.idsourceRecordIdAccela_Record_ID__c
Record.statuspermitStatusStatus__c
Contact.fullNameapplicantNameName
Address.addressLine1propertyAddressProperty_Address__c
Martini implementation pattern

A scheduled or supported callback-triggered workflow retrieves changed Records, resolves related Contacts and Addresses, normalizes agency-specific statuses, validates required fields, and upserts Salesforce objects. The workflow stores the Accela identifier as an external key, retries transient API failures, and routes permission or validation errors for review.

Martini capabilities used
  • workflows
  • API consumption
  • scheduling
  • data mapping
  • business rules
  • error handling

Pattern 2: Route Accela Inspections to ServiceNow

When to use this pattern

Use this pattern when inspection activity needs operational task management, assignment, or service-level tracking in ServiceNow. Bidirectional updates should be limited to fields with clearly defined ownership.

Integration direction
Accela
Martini
ServiceNow
Example Mapping
Accela FieldCanonical FieldTarget Field
Inspection.idinspectionIdCorrelation_ID
Inspection.typeinspectionTypeShort description
Inspection.statusinspectionStatusState
Inspection.commentsinspectionNotesWork notes
Martini implementation pattern

Martini retrieves new or changed Inspections, maps inspection types and statuses to ServiceNow work items, checks the correlation key before creating or updating a task, and optionally sends approved assignment or status changes back to Accela. Duplicate detection, retry limits, and dead-letter or exception handling prevent repeated work-item creation.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • business rules
  • idempotency
  • error handling

Pattern 3: Transfer Accela Documents to SharePoint

When to use this pattern

Use this pattern when agency staff need selected Accela Documents available in a governed document repository while retaining traceability to the originating Record. Document permissions, supported content operations, and duplicate rules should be confirmed before production use.

Integration direction
Accela
Martini
SharePoint
Example Mapping
Accela FieldCanonical FieldTarget Field
Document.idsourceDocumentIdAccelaDocumentId
Document.fileNamefileNameFile name
Document.contentTypemimeTypeContent type
Document.recordIdsourceRecordIdAccelaRecordId
Martini implementation pattern

A Martini workflow retrieves eligible Document metadata and content, validates file size and type, checks the source document identifier and version against a correlation store, transfers the file to SharePoint, and records the destination identifier. Partial failures are retried without re-uploading completed documents.

Martini capabilities used
  • workflows
  • API consumption
  • file handling
  • data mapping
  • validation
  • error handling

Pattern 4: Publish Accela Parcel and Permit Data to ArcGIS

When to use this pattern

Use this pattern when an agency needs permit, address, and parcel information available for spatial analysis or map-based operations. Incremental extraction and checkpointing reduce load and support restartable synchronization.

Integration direction
Accela
Martini
Esri ArcGIS
Example Mapping
Accela FieldCanonical FieldTarget Field
Record.idpermitIdPermit_ID
Address.addressLine1siteAddressSite_Address
Parcel.idparcelIdParcel_ID
Record.statuspermitStatusStatus
Martini implementation pattern

A scheduled workflow reads the last checkpoint, retrieves changed Records, Addresses, and Parcels through Accela REST APIs, transforms agency-specific values into the ArcGIS schema, validates spatial and identifier fields, and publishes or upserts the results. Rate limiting, bounded batches, retries, and reconciliation handle incomplete runs.

Martini capabilities used
  • scheduling
  • workflows
  • API consumption
  • data mapping
  • business rules
  • checkpointing
  • monitoring

Applications commonly integrated with Accela

Accela is commonly positioned at the center of public-sector permitting, licensing, inspection, spatial, document, and administrative processes. The following applications represent practical integration targets; specific packages, APIs, and agency implementations should be verified for each deployment.

Application Scenario Direction Martini Pattern
Salesforce Synchronize Accela permits, applicants, organizations, and case milestones with constituent or customer-facing processes. Accela → Martini → Salesforce A scheduled or callback-triggered workflow retrieves changed Records and related Contacts or Addresses, maps them to Salesforce objects, applies upsert keys, and routes transient failures for retry.
ServiceNow Coordinate inspection-related tasks, service requests, approvals, and operational work items with Accela processes. Accela → Martini → ServiceNow Martini polls or receives supported Accela notifications for Inspections, maps them to ServiceNow work items, maintains correlation identifiers, and optionally sends approved status updates back to Accela.
Esri ArcGIS Exchange parcel, address, location, and permit information for spatial analysis and map-based workflows. Accela → Martini → Esri ArcGIS A scheduled workflow extracts changed Records, Addresses, and Parcels, transforms them into the target spatial schema, publishes them to ArcGIS, and stores a synchronization checkpoint.
Microsoft Dynamics 365 Synchronize applicant, organization, service, or case information with Microsoft business applications. Accela → Martini → Microsoft Dynamics 365 Martini consumes Accela REST resources, normalizes agency-specific fields, applies ownership and validation rules, and upserts corresponding Dynamics 365 data with retryable error handling.
Tyler Technologies Munis Exchange licensing, permitting, fee, payment, or financial information with municipal administration systems. Accela → Martini → Tyler Technologies Munis A workflow retrieves approved Accela transaction data, maps agency-specific identifiers and financial fields, submits the target payload, and records correlation and reconciliation results.
DocuSign Route selected agency Documents for electronic signature and return signed document status or content. Accela → Martini → DocuSign Martini retrieves eligible Accela Documents and metadata, submits them to DocuSign, tracks envelope status, and transfers completed documents or status updates back to the required system.
Microsoft Power BI Publish curated permit, inspection, licensing, and processing metrics for reporting. Accela → Martini → Microsoft Power BI A scheduled Martini workflow extracts incremental Accela data, applies reporting transformations, and publishes a stable analytical payload or writes it to an approved intermediary process.
Oracle NetSuite Exchange selected billing, customer, or transaction data where an agency or related organization uses NetSuite. Accela → Martini → Oracle NetSuite Martini orchestrates REST-based extraction and delivery, maps Accela identifiers to NetSuite keys, validates transaction states, and handles duplicate or transient failures through controlled retries.

How to build a Accela integration in Martini

Objective

Establish access to the target Accela tenant, environment, agency, and application configuration without exposing credentials in workflows or logs.

Instructions in Martini

  • Register or obtain the Accela application credentials and required permissions
  • Configure OAuth 2.0 client information, token settings, tenant, environment, and agency context
  • Store client secrets and environment-specific values in Martini secrets or protected configuration
  • Confirm access to the required Accela resources with the target service identity

Objective

Select an event-driven or scheduled entry point based on the capabilities confirmed for the target Accela deployment.

Instructions in Martini

  • Use a supported Accela callback or event notification when the required event types are available
  • Use a scheduler for polling, reconciliation, or deployments without usable callbacks
  • Define the synchronization scope, checkpoint strategy, and expected execution frequency
  • Set bounded concurrency and processing limits for the target environment

Objective

Read Accela resources reliably, including related objects, pagination, incremental criteria, and document content where required.

Instructions in Martini

  • Call the Accela REST API from the workflow
  • Follow pagination until the selected page range is complete
  • Use stable incremental filters or modification criteria where supported
  • Retrieve related Records, Inspections, Contacts, Addresses, Parcels, or Documents as required
  • Treat resource availability and fields as agency-specific configuration

Objective

Coordinate multi-step Accela operations and downstream calls while preserving correlation and restartability.

Instructions in Martini

  • Sequence authentication, resource retrieval, enrichment, transformation, and target writes
  • Persist source identifiers, checkpoints, and document correlations where needed
  • Use conditional routing for different Record, Inspection, or status types
  • Separate transient failures from authentication, permission, validation, and missing-resource errors

Objective

Convert Accela’s agency-specific resource structures into canonical and destination-specific models.

Instructions in Martini

  • Map Accela fields to a canonical integration model
  • Normalize statuses, dates, addresses, identifiers, and custom fields
  • Transform Document metadata and content for the destination system
  • Validate required fields and preserve source identifiers for traceability

Objective

Enforce agency and destination rules before creating, updating, or routing data.

Instructions in Martini

  • Define ownership for fields exchanged bidirectionally
  • Use Accela identifiers as external keys for idempotent upserts
  • Apply eligibility, status, duplicate, and routing rules
  • Handle deleted, canceled, late-arriving, and concurrently modified resources explicitly

Common Accela data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
RecordsRepresent permits, licenses, planning cases, code-enforcement cases, and other agency transactions.Salesforce, ServiceNow, Microsoft Dynamics 365, Tyler Technologies Munis, Esri ArcGISMartini retrieves Records through REST APIs, applies agency-specific mappings and status rules, and upserts them using stable Accela identifiers.
InspectionsRepresent inspection types, schedules, results, comments, and inspection-related status information.ServiceNow, Salesforce, Microsoft Power BI, Esri ArcGISMartini can poll or receive supported notifications, map inspection results to operational objects, and apply idempotency and retry rules.
AddressesStore locations associated with Records, applicants, properties, and agency transactions.Esri ArcGIS, Salesforce, Microsoft Dynamics 365Martini resolves and normalizes address fields, validates required values, and associates addresses with the target Record or spatial object.
ParcelsRepresent property parcels associated with applications, permits, inspections, and locations.Esri ArcGIS, Microsoft Power BI, SalesforceMartini extracts Parcels with related identifiers, transforms them into spatial or reporting schemas, and processes changes incrementally where supported.
ContactsRepresent applicants, owners, contractors, professionals, and other parties involved in agency processes.Salesforce, Microsoft Dynamics 365, ServiceNowMartini maps Contacts to downstream party models, applies deduplication keys, and preserves Accela identifiers for subsequent updates.
DocumentsRepresent files and attachments associated with Records or agency transactions.SharePoint, DocuSign, Salesforce, enterprise document repositoriesMartini retrieves document metadata or content where exposed, transfers files, checks duplicate or version information, and records destination identifiers.

Authentication and security considerations

OAuth 2.0 application authentication

Accela integrations generally use OAuth 2.0 access tokens issued to a registered application. The required client credentials, permissions, scopes, token settings, tenant, environment, agency, and context parameters depend on the target Civic Platform deployment.

Protecting credentials and access

  • Store client secrets, tokens, environment URLs, and agency-specific configuration in Martini secrets or protected environment configuration.
  • Use the least-privileged Accela application permissions required for the integration.
  • Handle token expiration, refresh, revoked applications, invalid credentials, and insufficient permissions as distinct conditions.
  • Do not place credentials or sensitive payloads in workflow logs or integration messages unnecessarily.

Operational considerations for Accela integrations

Agency-specific schemas

Record types, custom fields, inspection types, statuses, fee structures, resources, and permissions can vary by agency, environment, Civic Platform version, and enabled products. Validate the target deployment rather than assuming a universal schema.

Throughput and synchronization

  • Follow REST pagination and use modification timestamps, status filters, or other stable incremental criteria where available.
  • Confirm rate limits and use bounded concurrency, request pacing, exponential backoff, and retry limits.
  • Persist checkpoints and advance them only after the corresponding page or unit of work succeeds.
  • Use stable Accela identifiers and idempotent upserts to prevent duplicate downstream objects.

Events, documents, and change management

  • Verify which event types, resources, and agencies support callbacks; schedule reconciliation when event coverage is incomplete.
  • For Documents, account for file size, content type, permissions, versioning, duplicate detection, and partial transfers.
  • Monitor API versions, custom fields, enumerations, and configuration changes, and test mappings against representative agency data.

Why use Martini instead of scripts or point-to-point integrations?

Centralized orchestration

Martini provides a workflow layer for authentication, pagination, related-resource retrieval, transformation, business rules, target writes, and exception handling. This avoids duplicating Accela-specific logic across point-to-point scripts.

Maintainable integration assets

  • Expose normalized APIs so downstream consumers do not each need to understand agency-specific Accela models.
  • Reuse mappings, validation, authentication configuration, and error-handling patterns across Records, Inspections, Documents, and other resources.
  • Support scheduled, callback-driven, and restartable workflows with checkpoints and controlled retries.
  • Keep credentials and deployment-specific values separate from workflow logic for safer promotion across environments.

Operational visibility

Centralized workflows make correlation identifiers, failed requests, retry behavior, checkpoints, and reconciliation outcomes easier to monitor than independent scripts or tightly coupled application integrations.

Frequently asked questions

How can Accela be integrated with enterprise systems?

Accela is primarily integrated through its Civic Platform REST API, using OAuth 2.0 application authentication to access resources such as Records, Inspections, Contacts, Addresses, Parcels, and Documents. Depending on the agency deployment, event notifications or outbound callbacks may also be available. Scheduled, paginated REST synchronization is the fallback when event coverage is incomplete.

Can Martini integrate with Accela?

Yes. Martini can consume Accela REST APIs, authenticate using the configured OAuth 2.0 application flow, receive supported callbacks through an API-triggered workflow, map Accela resources, transfer documents, and expose normalized APIs for downstream systems.

Do I need a connector to integrate Accela with Martini?

No. A dedicated Accela connector is not required. Martini can integrate using Accela’s confirmed native REST APIs, OAuth 2.0 authentication, supported callbacks or event notifications, and document-related API operations.

Is there any extra Lonti cost to integrate Accela with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Accela. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Accela, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.

Which Accela integration methods should new projects use?

The Accela Civic Platform REST API should generally be evaluated first because it is the primary documented application-integration interface. OAuth 2.0 is the typical authentication approach. Event notifications or callbacks can be used when the target agency explicitly supports the required events; a general-purpose bulk API and current recommended SOAP interface were not confirmed.

Can Martini receive Accela events or webhooks?

Only when the target Accela deployment exposes a supported outbound callback or event-notification mechanism for the required resource and action. Coverage is deployment-specific rather than universal. Martini can receive supported callbacks and supplement them with scheduled REST reconciliation or polling.

How does synchronization and duplicate prevention work with Accela?

Martini can use Accela identifiers as external keys, retrieve resources incrementally where supported, follow pagination, and persist checkpoints. Downstream upserts, document version or checksum checks, bounded retries, and reconciliation workflows help prevent duplicate records and detect missed changes.

Can Martini expose an API façade for Accela?

Yes. Martini can expose a controlled REST API that presents a normalized Accela view to downstream applications. The façade can orchestrate Accela REST calls, resolve related resources, apply authorization and business rules, transform responses, and centralize error handling without requiring each consumer to understand agency-specific Accela configuration.

Related Martini documentation

API Integration

Workflows

Data Processing

Security and Operations

Connect Accela with Martini

Use Martini to build secure, maintainable Accela integrations around REST APIs, supported callbacks, document operations, and scheduled synchronization workflows.

EXPLORE MARTINI
BOOK A DEMO