.png)
Procore Integration Guide
Integrate Procore construction data with enterprise systems through REST APIs, selected webhook notifications, OAuth 2.0, and orchestrated Martini workflows.
Procore integration options at a glance
Procore’s primary integration mechanism is its REST API, which provides access to companies, projects, users, vendors, commitments, RFIs, submittals, change events, and other project resources subject to permissions and product configuration. Procore also provides webhook-style notifications for selected resources and events, allowing Martini to receive callbacks and retrieve the current resource through the API. OAuth 2.0 secures registered applications, while company and project context controls access. For larger synchronizations, Martini can coordinate pagination, scheduled polling, checkpoints, batching, rate-limit-aware retries, and selected file or attachment transfers. Bulk and asynchronous capabilities must be confirmed per resource.
| Integration point | Supported by Procore? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Read and manage companies, projects, users, vendors, commitments, RFIs, submittals, change events, and other permitted resources. | Martini can consume Procore REST APIs, transform JSON, apply validation and business rules, and expose normalized APIs to downstream systems. |
| Webhooks / outbound callbacks | Limited | Receive notifications for selected Procore resources and events, subject to the resource, event type, subscription model, and scope. | Martini can expose an API or workflow entry point, validate callbacks, deduplicate notifications, retrieve the current resource, and process work asynchronously. |
| Authentication | Yes | Registered Procore applications use OAuth 2.0 bearer tokens, with access constrained by application permissions and company or project context. | Martini can keep client secrets and tokens in secure configuration, invoke authenticated APIs, and support controlled credential rotation. |
| File / attachment APIs | Limited | Selected document and resource APIs provide file metadata, download URLs, uploads, or attachment operations depending on the resource. | Martini can separate metadata from binary transfer, retrieve authenticated downloads, stream files, and preserve filenames, MIME types, versions, and source IDs. |
| Bulk / asynchronous / batch APIs | Limited | Bulk, batch, or asynchronous behavior varies by Procore resource and should not be assumed platform-wide. | Martini can combine paginated reads, scheduled checkpoints, internal batching, bounded retries, and reconciliation workflows where resource APIs permit. |
| Database / analytics access | Limited | Procore offers separate analytics and reporting capabilities, but direct operational database access is not a standard integration method. | Martini should use documented Procore APIs or an officially provisioned analytics/export interface rather than connecting to Procore’s production database. |
| Scheduled synchronization | Yes | Scheduled polling supports resources without the required webhook event and enables periodic reconciliation of project and operational data. | Martini scheduler-triggered workflows can paginate endpoints, persist checkpoints, compare source identifiers, and retry failed work. |
How Procore exposes data and business events
Procore REST APIs
Procore REST APIs are the primary integration mechanism for reading and managing company, project, and project-level resources. Availability and fields depend on the API resource, product configuration, and caller permissions.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with OAuth 2.0, calls the relevant Procore endpoint, handles pagination, transforms JSON into a canonical model, applies business rules, and writes to a target system or exposes a normalized Martini API.
Implementation sequence
Procore Webhooks
Procore provides webhook-style notifications for supported resources and events, but coverage is not universal. Payloads may identify the affected resource rather than contain its complete current representation.
Martini implementation pattern
Martini implementation pattern: expose a callback API, validate the notification, acknowledge quickly, retrieve the current Procore resource through REST, deduplicate and route the event, then process downstream work asynchronously.
Implementation sequence
Procore Scheduled Synchronization
Scheduled REST polling is appropriate when the required webhook is unavailable or when periodic reconciliation is needed. Endpoint filters, modification timestamps, pagination, and checkpoints must be confirmed for each resource.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow that reads changed resources, stores a durable checkpoint, transforms records, applies idempotent writes, and records failures for replay and reconciliation.
Implementation sequence
Procore File and Attachment APIs
Selected Procore document and resource APIs support file metadata and, depending on the resource, downloads, temporary URLs, uploads, or attachment operations. Permissions and URL lifetime require validation.
Martini implementation pattern
Martini implementation pattern: identify changed files, retrieve metadata and permitted content, stream the binary payload to a document target, and preserve project, folder, version, MIME, and source identifiers.
Implementation sequence
Common Procore integration patterns
Pattern 1: Sync projects and commitments to an ERP
When to use this pattern
Use this pattern when construction project, vendor, commitment, and cost data must be aligned with accounting or procurement platforms. A scheduled workflow is appropriate when resource-specific webhook coverage is unavailable.
Integration direction
Example Mapping
| Procore Field | Canonical Field | Target Field |
|---|---|---|
| Projects.id | project.sourceId | job.externalId |
| Vendors.id | vendor.sourceId | vendor.externalId |
| Commitments.amount | commitment.amount | purchaseOrder.amount |
| Commitments.status | commitment.status | purchaseOrder.status |
Martini implementation pattern
Martini reads paginated Procore Projects, Vendors, and Commitments, resolves company and project context, maps financial and status fields, validates currency and accounting dimensions, and performs idempotent upserts. Failed records receive bounded retries and durable reconciliation entries.
Martini capabilities used
- workflows
- scheduling
- API consumption
- pagination orchestration
- data mapping
- business rules
- error handling
Pattern 2: Synchronize RFIs and Submittals with collaboration workflows
When to use this pattern
Use this pattern to notify enterprise teams about new or changed RFIs and Submittals, escalate overdue work, and optionally route approved status changes back to Procore where the target API supports the update.
Integration direction
Example Mapping
| Procore Field | Canonical Field | Target Field |
|---|---|---|
| RFIs.id | question.sourceId | case.externalReference |
| RFIs.status | question.status | case.status |
| Submittals.specification_section | submittal.section | workItem.category |
| Submittals.due_date | submittal.dueDate | workItem.dueDate |
Martini implementation pattern
A Martini workflow consumes supported events or polls for changes, retrieves current objects, normalizes statuses and dates, applies project-specific routing, and writes collaboration or service records. Write-back is restricted by explicit ownership and Procore endpoint permissions.
Martini capabilities used
- API consumption
- webhook handling
- data mapping
- conditional routing
- validation
- error handling
Pattern 3: Process Procore webhook events
When to use this pattern
Use this pattern for supported Procore event and resource combinations where downstream systems need timely project updates without waiting for a full polling interval.
Integration direction
Example Mapping
| Procore Field | Canonical Field | Target Field |
|---|---|---|
| event.resource_id | event.sourceResourceId | message.resourceId |
| event.project_id | event.projectId | message.projectId |
| event.event_type | event.type | message.eventType |
Martini implementation pattern
Martini receives the callback through an API entry point, validates its scope, deduplicates repeated notifications, retrieves the current Procore object, and publishes a normalized message after successful retrieval. Out-of-order events and transient failures are handled through durable state and replay.
Martini capabilities used
- API exposure
- webhook handling
- workflow orchestration
- deduplication
- messaging
- retry handling
Pattern 4: Transfer project documents to SharePoint
When to use this pattern
Use this pattern when project documents or attachments must be archived or distributed in an enterprise repository while preserving Procore project and version context.
Integration direction
Example Mapping
| Procore Field | Canonical Field | Target Field |
|---|---|---|
| file.name | document.fileName | file.name |
| file.mime_type | document.contentType | file.contentType |
| file.project_id | document.projectId | file.projectReference |
| file.version | document.version | file.version |
Martini implementation pattern
Martini identifies changed permitted files, retrieves metadata and content or a temporary download URL, streams the file to SharePoint, and records the source identifier, version, folder, and timestamps. Large-file and authentication failures are retried within bounded limits and reconciled separately.
Martini capabilities used
- workflows
- file handling
- API consumption
- metadata mapping
- business rules
- monitoring
- error handling
Applications commonly integrated with Procore
Procore can be integrated with adjacent construction, finance, collaboration, scheduling, document, and customer-management products through their documented APIs and supported file or event mechanisms. Exact synchronization scope should be confirmed for each customer’s product configuration and permissions.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize construction customers, accounts, contacts, opportunities, and project delivery status across customer and project teams. | Salesforce → Martini → Procore | Use Salesforce and Procore APIs in a Martini workflow, map account and project identifiers, apply project-initiation rules, and maintain an external-ID cross-reference for bidirectional updates. |
| Sage 300 Construction and Real Estate | Transfer vendors, commitments, cost information, invoices, and project financial data between construction operations and accounting. | Procore → Martini → Sage 300 Construction and Real Estate | Schedule paginated reads of Procore Projects, Vendors, and Commitments, normalize financial fields, validate accounting dimensions, and upsert records with durable retry and reconciliation handling. |
| Oracle Primavera P6 | Align project schedules, activities, milestones, and project identifiers with Procore project execution data. | Oracle Primavera P6 → Martini → Procore | Orchestrate schedule retrieval and Procore REST updates, map project and activity identifiers, enforce ownership rules, and route unsupported or failed updates to a reconciliation queue. |
| Autodesk Construction Cloud | Exchange selected project, document, issue, drawing, or coordination information across construction platforms. | Procore → Martini → Autodesk Construction Cloud | Retrieve permitted Procore resources or files, transform metadata into the Autodesk model, preserve source identifiers and versions, and process write failures asynchronously. |
| Microsoft Dynamics 365 | Synchronize accounts, vendors, projects, purchase orders, commitments, and financial or operational status. | Procore → Martini → Microsoft Dynamics 365 | Use API-led workflows for bidirectional synchronization, map company and project context, apply financial validation rules, and use idempotent upserts keyed by source IDs. |
| Oracle NetSuite | Connect Procore project and commitment data with financial, procurement, vendor, and billing processes. | Procore → Martini → Oracle NetSuite | Schedule Procore extraction, transform project and cost data into NetSuite structures, validate accounting mappings, and return selected status or reference identifiers after successful writes. |
| DocuSign | Send contracts, commitments, change orders, or related documents for electronic signature and process envelope status. | Procore → Martini → DocuSign | Retrieve eligible Procore documents, invoke DocuSign APIs, track envelope and source identifiers, and route completion or rejection events back through a controlled workflow. |
| Microsoft SharePoint | Archive or distribute Procore project documents and attachments in an enterprise document repository. | Procore → Martini → Microsoft SharePoint | Retrieve permitted file metadata and content or download URLs, stream files to SharePoint, preserve project and folder context, and reconcile versions and deletions. |
How to build a Procore integration in Martini
Objective
Register a Procore application, select the appropriate OAuth 2.0 flow, and configure company and project permissions without embedding credentials in workflows.
Instructions in Martini
- Register the Procore developer application
- Configure OAuth 2.0 credentials and scopes
- Store secrets in Martini secure configuration
- Record company, project, and external-system identifiers
Objective
Select a Procore webhook for a supported resource and event, or use scheduled polling when webhook coverage is unavailable or reconciliation is required.
Instructions in Martini
- Verify event and resource coverage
- Expose a Martini callback API when appropriate
- Configure a scheduler for polling workflows
- Define the checkpoint or event deduplication strategy
Objective
Receive the event or retrieve Procore resources through REST APIs, resolving project context and handling pagination according to the endpoint.
Instructions in Martini
- Validate callback scope and identifiers
- Call the relevant Procore REST endpoint
- Follow endpoint-specific pagination
- Retrieve the current resource after a notification
Objective
Use a Martini workflow to coordinate source retrieval, enrichment, validation, target calls, state management, and asynchronous processing.
Instructions in Martini
- Separate notification handling from long-running work
- Load reference and cross-reference data
- Route records by project or business rule
- Persist checkpoints and correlation information
Objective
Transform Procore JSON, file metadata, and resource fields into a canonical model and target-specific representation.
Instructions in Martini
- Map stable Procore IDs to target identifiers
- Normalize statuses, dates, and financial values
- Preserve project and company context
- Validate required fields before writes
Objective
Apply ownership, permission, financial, duplicate, and write-back rules before changing downstream or Procore data.
Instructions in Martini
- Check resource permissions and system-of-record ownership
- Apply idempotent create and update logic
- Reject invalid financial or project mappings
- Deduplicate webhook notifications
Common Procore data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Companies | Represent Procore organizations and contracting companies and establish the access context for project resources. | Salesforce, Microsoft Dynamics 365, Sage 300 Construction and Real Estate | Martini retrieves company identifiers and metadata, maps them to a canonical organization model, and preserves source IDs for correlation. |
| Projects | Represent construction projects and associated configuration, ownership, and project context. | Oracle NetSuite, Microsoft Dynamics 365, Oracle Primavera P6, Salesforce | Martini synchronizes project identifiers and status, validates company context, and applies create-versus-update rules. |
| Users | Represent people with access to Procore companies and projects. | Salesforce, Microsoft Dynamics 365, identity directories | Martini maps user identity and project access fields where permitted, applies privacy and permission rules, and handles incremental updates. |
| Vendors | Represent external organizations participating in a project and support procurement or cost processes. | Sage 300 Construction and Real Estate, Oracle NetSuite, Microsoft Dynamics 365 | Martini normalizes vendor identifiers and financial attributes, validates required target fields, and performs idempotent upserts. |
| Commitments | Represent subcontracts, purchase orders, and related committed-cost records. | Sage 300 Construction and Real Estate, Oracle NetSuite, Microsoft Dynamics 365 | Martini maps commitment values, statuses, vendors, projects, and financial dimensions while preserving audit identifiers and handling retries. |
| RFIs | Manage project questions, responses, ownership, and status. | Salesforce, Microsoft Dynamics 365, collaboration platforms | Martini retrieves current RFI details after notifications, maps status and participants, and routes overdue or changed items according to project rules. |
Authentication and security considerations
OAuth 2.0 and permissions
Procore integrations use OAuth 2.0 applications and bearer access tokens. Access is additionally constrained by application permissions, user or application identity, company context, project context, and resource-level permissions.
Credential protection
- Store client secrets and tokens in Martini secure configuration rather than payloads or source code.
- Request only the scopes and Procore permissions required by the workflow.
- Plan for token expiration, revocation, rotation, and separate environments.
- Validate incoming webhook requests according to Procore’s documented callback model.
Operational considerations for Procore integrations
Rate limits and retries
Confirm current Procore limits for the relevant application and endpoint. Use pagination, bounded exponential backoff, response retry guidance, and durable replay for throttled or transient requests.
Consistency and idempotency
Store Procore resource IDs with downstream IDs, deduplicate webhook notifications, and implement durable idempotency when an operation does not provide a suitable idempotency key.
Schema and permissions
Pin integrations to documented API versions where possible, tolerate additive JSON fields, validate required fields, and test with production-like company and project permissions.
Files and reconciliation
Validate download URL lifetime, content type, size, and access requirements. Preserve project, folder, version, and source metadata, and run scheduled reconciliation even when webhooks are enabled.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini centralizes Procore authentication, API calls, webhook handling, pagination, transformations, business rules, target writes, and error paths in maintainable workflows.
Reusable integration assets
Teams can expose controlled APIs, reuse mappings and validation logic, and separate notification receipt from asynchronous processing without creating tightly coupled point-to-point scripts.
Operational control
Durable checkpoints, correlation data, retries, monitoring, and reconciliation provide a clearer operational model for project, financial, RFI, submittal, and document synchronization.
Frequently asked questions
Procore is integrated primarily through its REST APIs, which expose company, project, and project-level resources. Supported webhook notifications can initiate event-driven processing, while scheduled REST polling supports resources without the required event coverage. OAuth 2.0, company and project context, permissions, pagination, and resource-specific API behavior must be accounted for.
Yes. Martini can integrate with Procore by consuming Procore REST APIs, receiving supported webhook callbacks, orchestrating scheduled synchronization, transforming Procore JSON and file metadata, and exposing APIs for downstream systems or controlled write-back.
No. A dedicated Procore connector is not required. Martini can use Procore’s confirmed native integration mechanisms, including REST APIs, OAuth 2.0, selected webhook callbacks, scheduled retrieval, and supported file or attachment endpoints.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Procore. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Procore, cloud infrastructure, or other third-party systems depending on subscriptions, API usage, and deployment model.
Use Procore REST APIs as the primary mechanism. Use webhook-style notifications for specifically supported resources and events, followed by a REST retrieval of the current object. Use scheduled pagination and checkpoints for unsupported events, reconciliation, and large synchronizations. GraphQL and current SOAP APIs were not confirmed for general Procore use.
No. Procore webhook coverage is resource- and event-dependent. Before implementation, verify the event type, resource, payload shape, subscription scope, and callback retry behavior. Martini can receive supported callbacks and use scheduled REST polling where webhooks are unavailable.
Martini can retrieve paginated resources or respond to selected events, map Procore objects to a canonical model, apply validation and business rules, and write idempotent updates to target systems. Checkpoints, source-to-target ID mappings, and periodic reconciliation support incremental synchronization.
A Martini implementation can use bounded exponential backoff for transient failures and throttling, avoid blind retries of non-idempotent creates, deduplicate webhook notifications, and persist failed work for replay. Logs should retain company, project, resource, correlation, HTTP status, retry, and downstream identifiers.
Yes. Martini can expose a controlled REST API that normalizes selected Procore resources for downstream consumers, applies authorization and business rules, and orchestrates calls to Procore. This façade does not replace Procore permissions or make unsupported resource operations available.
Related Martini documentation
Procore APIs
Workflows
Connect Procore with your enterprise systems
Use Martini to build maintainable Procore integrations around REST APIs, selected webhook events, OAuth 2.0, workflow orchestration, data transformation, and reliable synchronization.