.png)
Teamwork Integration Guide
Integrate Teamwork project data with enterprise applications through REST APIs, selective webhooks, scheduled workflows, and secure authentication.
Teamwork integration options at a glance
Teamwork provides a documented REST API for reading and modifying projects, tasks, people, companies, milestones, time records, files, and related resources. Selective webhook notifications can support near-real-time processing for supported objects and events, while scheduled REST workflows provide polling and reconciliation where webhook coverage is incomplete. Authentication may use OAuth 2.0 or credential-based access, depending on the API version and account requirements. Martini can consume these APIs, receive Teamwork callbacks through controlled endpoints, paginate and checkpoint retrievals, map data into canonical models, transfer files, and route results to enterprise applications.
| Integration point | Supported by Teamwork? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Read and modify Projects, Tasks, People, Companies, Milestones, Time records, Files, and related project-management resources. | Martini can consume Teamwork REST endpoints, paginate responses, transform payloads, apply business rules, and write results to downstream APIs or databases. |
| Webhooks / outbound callbacks | Limited | Receive notifications for selected Teamwork resource events where webhook coverage is available. | Martini can expose a controlled API or consume webhook traffic through a workflow, validate the notification, retrieve the current object, and process duplicates safely. |
| File / attachment APIs | Yes | Retrieve metadata and content for Files associated with projects, tasks, messages, or other Teamwork resources, and upload or associate files where supported. | Martini can transfer files between Teamwork and other APIs while handling content type, size, permissions, download URLs, and retention rules. |
| OAuth 2.0 | Yes | Authorize integrations that act on behalf of Teamwork users or support multiple customer accounts. | Martini can keep client secrets and tokens in protected environment configuration and use authenticated API workflows with the required permissions. |
| API keys or personal credentials | Limited | Support controlled account-level or user-level internal access where the applicable Teamwork API version and plan permit credential-based authentication. | Martini can send the required authorization headers or credential format, provided credentials are confirmed for the target Teamwork environment and stored as secrets. |
| Pagination and incremental retrieval | Yes | Process paginated collections and retrieve changed resources using updated timestamps, activity endpoints, webhook notifications, or other documented change indicators. | Martini can persist cursors, timestamps, and checkpoints outside individual executions so synchronization can resume without skipping or duplicating objects. |
| Bulk / async / batch APIs | Not confirmed | Endpoint-specific bulk behavior may exist, but a general-purpose bulk or asynchronous Teamwork API was not verified. | Martini can orchestrate controlled batches through documented REST endpoints, but implementation should not assume general bulk semantics until the selected API documentation confirms them. |
| Database access | No | Direct access to Teamwork's hosted application database was not verified and is not an expected integration mechanism. | Martini should use Teamwork REST APIs and supported notifications rather than attempting direct database connectivity. |
How Teamwork exposes data and business events
Teamwork REST APIs
Teamwork's primary documented integration surface is HTTP-based REST APIs for project-management resources, including Projects, Tasks, People, Companies, Milestones, Time records, and Files. Endpoint availability and paths should be confirmed against the selected API version.
Martini implementation pattern
Martini workflows authenticate to Teamwork, call the required REST endpoints, handle pagination and response validation, map the returned objects into canonical or target-specific structures, and invoke downstream APIs or persistence services.
Implementation sequence
Teamwork Webhooks
Teamwork supports webhook-style notifications for selected resource events rather than universal event coverage. A notification may contain an identifier or summary that requires a follow-up REST request for the complete object.
Martini implementation pattern
Martini exposes a controlled receiving endpoint or webhook workflow, validates the callback using the documented Teamwork verification approach, acknowledges appropriately, retrieves the current resource, and routes it to downstream systems. Scheduled reconciliation covers unsupported or missed events.
Implementation sequence
Teamwork File APIs
Teamwork exposes file-related functionality for Files and attachments associated with project-management resources. File responses may contain metadata, content, a download URL, or a separate attachment representation depending on the endpoint.
Martini implementation pattern
Martini retrieves the required metadata and content, validates content type and size, transfers the file to the target API or storage service, and records source identifiers and outcomes without placing file contents or authorization headers in logs.
Implementation sequence
Scheduled Teamwork Synchronization
Scheduled retrieval is appropriate for objects or events without webhook coverage and for periodic reconciliation. Teamwork collection endpoints should be treated as paginated unless the endpoint explicitly states otherwise.
Martini implementation pattern
A Martini scheduler starts an incremental workflow using a stored timestamp, cursor, or other supported change indicator. The workflow processes pages, persists progress after successful work, and periodically performs bounded reconciliation to identify missed callbacks or changes.
Implementation sequence
Common Teamwork integration patterns
Pattern 1: Create delivery projects from CRM opportunities
When to use this pattern
Use this pattern when a Salesforce or HubSpot opportunity reaches a delivery-ready stage and Teamwork should receive a Project with initial work structure. The workflow should resolve the customer and users before creating dependent Tasks and Milestones, and should safely handle retries.
Integration direction
Example Mapping
| Teamwork Field | Canonical Field | Target Field |
|---|---|---|
| opportunity.id | externalOpportunityId | Project.externalReference |
| opportunity.name | projectName | Project.name |
| company.id | customerExternalId | Company.id |
| closeDate | deliveryStartDate | Project.startDate |
Martini implementation pattern
Martini consumes the source application change, validates the delivery stage, searches Teamwork for an existing external reference, resolves the Company and People, and creates or updates the Project before writing dependent Tasks and Milestones. Failed calls are classified for retry without creating duplicates.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Synchronize Teamwork delivery status to a CRM
When to use this pattern
Use this pattern when sales or account teams need current delivery status, milestone dates, completion information, or project-owner data in Salesforce or HubSpot. Selective Teamwork webhooks can provide near-real-time updates, with scheduled polling for uncovered events.
Integration direction
Example Mapping
| Teamwork Field | Canonical Field | Target Field |
|---|---|---|
| Project.id | deliveryProjectId | Account.deliveryProjectId |
| Project.status | deliveryStatus | Opportunity.deliveryStatus |
| Milestone.dueDate | nextMilestoneDate | Opportunity.nextMilestoneDate |
| Project.completionPercentage | completionPercent | Account.deliveryCompletion |
Martini implementation pattern
Martini receives a supported notification or retrieves changed Projects, Tasks, and Milestones incrementally, enriches related data where required, applies status translation rules, and updates the CRM using the Teamwork identifier as an external key. A reconciliation workflow detects missed callbacks.
Martini capabilities used
- webhook-consuming workflows
- scheduled workflows
- incremental synchronization
- data mapping
- idempotency
- monitoring
Pattern 3: Post billable Teamwork time to finance
When to use this pattern
Use this pattern when approved or billable Teamwork Time records must support accounting, invoicing, or utilization processes in QuickBooks Online or Xero. The workflow should validate project, task, and user mappings before posting financial data.
Integration direction
Example Mapping
| Teamwork Field | Canonical Field | Target Field |
|---|---|---|
| TimeRecord.id | sourceTimeRecordId | Transaction.externalReference |
| TimeRecord.hours | quantity | LineItem.quantity |
| TimeRecord.billable | billableFlag | LineItem.billable |
| Project.id | projectExternalId | Transaction.projectReference |
Martini implementation pattern
A scheduled Martini workflow retrieves paginated Time records using an incremental change indicator, resolves People, Projects, and Tasks, validates accounting mappings, transforms hours and billable attributes, and posts the result. The source identifier prevents duplicate financial entries and transient failures enter controlled retry handling.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination
- validation
- data transformation
- retry handling
Pattern 4: Route Teamwork files to a document platform
When to use this pattern
Use this pattern when project or task Files need to be copied or referenced in Google Drive or another document-management API. It is suited to supported file events and can fall back to scheduled discovery when notifications are unavailable.
Integration direction
Example Mapping
| Teamwork Field | Canonical Field | Target Field |
|---|---|---|
| File.id | sourceFileId | DriveFile.properties.teamworkId |
| File.name | fileName | DriveFile.name |
| File.contentType | mimeType | DriveFile.mimeType |
| Project.id | projectExternalId | DriveFile.properties.projectId |
Martini implementation pattern
Martini receives or discovers the File, retrieves metadata and content through Teamwork's documented file endpoints, validates size and permissions, and transfers it to the document platform. Content hashes or source IDs support idempotency, while expired URLs and partial transfers are retried or quarantined.
Martini capabilities used
- webhook-consuming workflows
- file handling
- API orchestration
- data mapping
- business rules
- error handling
Applications commonly integrated with Teamwork
Teamwork can be connected with adjacent sales, collaboration, finance, support, development, and document platforms. These integrations typically use Teamwork REST APIs, selective webhook notifications, scheduled reconciliation, and application-specific APIs on the other side. Exact object coverage and direction should be confirmed during solution design.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize customers, opportunities, delivery projects, project status, and time information between sales and project delivery. | Salesforce → Martini → Teamwork | Trigger a workflow from Salesforce or a scheduled change query, resolve Companies and People, create or update Projects, then create dependent Tasks and Milestones using stable external references and idempotent REST operations. |
| HubSpot | Create Teamwork projects from won deals and return delivery milestones or project status to HubSpot. | HubSpot → Martini → Teamwork | Consume HubSpot changes, apply stage and ownership rules, map deal and customer fields to Teamwork Projects, and synchronize selected status updates back through a controlled workflow. |
| Jira | Coordinate software-development work with client-facing Teamwork projects, tasks, and milestones. | Jira → Martini → Teamwork | Map issue or task identifiers to Teamwork Tasks, translate statuses and dates, route updates in both directions where required, and prevent loops with source-system keys. |
| Slack | Notify delivery teams about project, task, milestone, or comment changes and optionally route selected actions back to Teamwork. | Teamwork → Martini → Slack | Receive supported Teamwork webhook notifications, retrieve the current resource, format a concise message, and call Slack for delivery while applying filtering and duplicate suppression. |
| QuickBooks Online | Transfer billable time, project, customer, or invoice-supporting information from Teamwork into finance processes. | Teamwork → Martini → QuickBooks Online | Schedule incremental retrieval of Time records, validate People, Projects, and Tasks mappings, transform billable attributes, and post entries using the Teamwork time-record identifier as an external key. |
| Xero | Synchronize billable time or project-related financial data with accounting workflows. | Teamwork → Martini → Xero | Poll approved or billable Time records, resolve project and user mappings, apply accounting rules, and submit idempotent transactions to Xero with retry handling for transient failures. |
| Zendesk | Connect support requests and customer context with delivery projects and implementation Tasks. | Zendesk → Martini → Teamwork | Map selected Zendesk tickets to Teamwork Projects or Tasks, preserve cross-system identifiers, and synchronize status or comments according to explicit routing and ownership rules. |
| Google Drive | Transfer or reference project documents and attachments across Teamwork and shared-drive locations. | Teamwork → Martini → Google Drive | Use a supported Teamwork notification or scheduled scan, retrieve file metadata and content, validate size and content type, and transfer the file while preserving source identifiers and access rules. |
How to build a Teamwork integration in Martini
Objective
Establish Teamwork access using the authentication method confirmed for the selected API version and account configuration.
Instructions in Martini
- Configure the Teamwork base URL and API version as environment settings
- Use OAuth 2.0 or approved credential-based access as appropriate
- Store client secrets, tokens, and credentials in Martini secrets or protected environment configuration
- Request only the Teamwork permissions required by the workflow
Objective
Select an event-driven, API-led, or scheduled trigger based on the required latency and Teamwork webhook coverage.
Instructions in Martini
- Use a Teamwork webhook-consuming workflow for supported resource events
- Use a Martini API when another system should initiate the integration
- Use a scheduler for polling, reconciliation, or objects without webhook coverage
- Define acknowledgment and timeout behavior for inbound callbacks
Objective
Obtain complete Teamwork objects rather than relying solely on webhook summaries or partial list responses.
Instructions in Martini
- Call the relevant Teamwork REST endpoint after receiving a notification
- Process collection endpoints with pagination
- Use updated timestamps, activity indicators, or other documented change filters for incremental retrieval
- Persist cursors, timestamps, and source identifiers outside the workflow execution
Objective
Coordinate dependent Teamwork resources and downstream calls in a reliable processing sequence.
Instructions in Martini
- Resolve Companies, People, and Projects before creating dependent Tasks or Milestones
- Separate webhook acknowledgment from longer downstream work where required
- Route objects to target APIs, queues, or persistence services
- Use reusable workflow logic for common authentication, mapping, and retry behavior
Objective
Convert Teamwork objects into canonical and target-specific models while preserving relationships and identifiers.
Instructions in Martini
- Map Teamwork IDs to stable external keys
- Translate statuses, dates, ownership, billable flags, and relationship references
- Handle optional fields, null values, and API-version differences
- Transfer file metadata and content separately when the target requires it
Objective
Enforce validation, duplicate prevention, permissions, and business decisions before writing target data.
Instructions in Martini
- Validate required fields and target mappings
- Search for existing external references before creating Projects, Tasks, or financial entries
- Apply routing rules for selected webhook events and supported objects
- Reject or quarantine invalid data with diagnostic identifiers
Common Teamwork data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Projects | Organize work, customers, tasks, milestones, files, messages, and project activity. | Salesforce, HubSpot, Jira, Slack, Google Drive | Martini resolves Companies and People first where needed, then creates or updates Projects using stable external identifiers and mapped dates, ownership, and status values. |
| Tasks | Represent assignable work with descriptions, due dates, priorities, statuses, dependencies, tags, and comments. | Jira, Salesforce, HubSpot, Zendesk | Martini maps task fields and relationships, applies status and ownership rules, and processes webhook or polling updates idempotently. |
| People | Represent users or collaborators assigned to work, associated with projects, or used for time tracking. | Salesforce, HubSpot, QuickBooks Online, Xero | Martini matches People by stable IDs or controlled email keys and validates permissions and project membership before creating dependent objects. |
| Companies | Represent customers, clients, partners, or organizations associated with projects and people. | Salesforce, HubSpot, Zendesk | Martini uses Companies as reference data, applies duplicate detection, and preserves Teamwork identifiers in downstream mappings. |
| Milestones | Represent significant project targets and delivery points associated with tasks and dates. | Salesforce, HubSpot, Jira, Slack | Martini synchronizes milestone dates, completion state, and ownership after resolving the parent Project, with validation for dependent Tasks. |
| Time records | Capture logged time associated with People, Tasks, Projects, and billable-work attributes. | QuickBooks Online, Xero, Salesforce | Martini retrieves records incrementally, validates project and user mappings, transforms billable fields, and posts entries idempotently using the source identifier. |
Authentication and security considerations
Authentication options
Teamwork integrations may use OAuth 2.0 for user-authorized or multi-account access, or credential-based access for controlled internal integrations where supported by the selected API version and plan.
Credential protection
- Store OAuth client secrets, tokens, API keys, and personal credentials in Martini secrets or protected environment configuration.
- Request only the Teamwork permissions required for each workflow.
- Keep credentials out of mappings, source code, and workflow logs.
Webhook security
Validate inbound Teamwork webhook requests using the verification method documented for the applicable Teamwork API. Redact authorization headers and sensitive project, customer, and file data from diagnostics.
Operational considerations for Teamwork integrations
Rate limits and pagination
Confirm current Teamwork limits for the selected API version and account plan. Process collection responses page by page, use controlled concurrency, and apply exponential backoff for transient 429 and 5xx responses.
Synchronization state
Persist cursors, timestamps, source IDs, and last-successful checkpoints outside individual workflow executions. Combine supported webhooks with scheduled reconciliation to detect missed notifications.
Idempotency and relationships
Use stable Teamwork IDs as external keys, check before creating dependent objects, and process duplicate callbacks safely. Resolve Companies, People, and Projects before writing related Tasks, Milestones, or Time records.
Files and schema changes
Handle file size, content type, permissions, and download URL behavior explicitly. Pin the API version, tolerate optional fields and nulls, and test mappings when Teamwork changes schemas or enumerations.
Observability
Separate authentication, validation, permission, not-found, rate-limit, and transient errors. Capture request identifiers and source object IDs, and route unrecoverable events to retry or dead-letter handling.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration over point-to-point code
Martini centralizes Teamwork API calls, webhook handling, scheduled reconciliation, transformations, target writes, and error policies in maintainable workflows rather than scattering logic across scripts.
Reusable integration assets
Teams can expose controlled APIs, reuse authentication and processing logic, and create consistent mappings for Projects, Tasks, People, Companies, Milestones, Time records, and Files.
Operational control
- Apply validation, business rules, pagination, checkpoints, idempotency, and retry handling in one integration layer.
- Support both near-real-time webhook processing and scheduled polling when Teamwork event coverage is selective.
- Use protected configuration and workflow-level observability without embedding credentials in application code.
Frequently asked questions
Teamwork can be integrated through its documented REST APIs, selective webhook-style notifications, file and attachment operations, and scheduled incremental retrieval. OAuth 2.0 or approved credential-based authentication can secure access, while workflows can synchronize Projects, Tasks, People, Companies, Milestones, Time records, and Files with other systems.
Yes. Martini can consume Teamwork REST APIs, receive supported Teamwork webhook notifications through a controlled API or workflow, run scheduled polling and reconciliation, transform Teamwork objects, and route results to enterprise applications. No dedicated native Martini Teamwork connector was verified in the supplied research.
No. A dedicated Teamwork connector is not required. Martini can use Teamwork's confirmed native integration mechanisms, including REST APIs, supported webhook notifications, file endpoints, OAuth or credential-based authentication, and scheduled workflows.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Teamwork. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Teamwork, cloud infrastructure, or other third-party systems based on subscriptions, API usage, and deployment model.
Use the Teamwork REST API as the primary integration method. Use selective webhook notifications for supported events that require near-real-time processing, and scheduled incremental polling or reconciliation for uncovered resources, missed callbacks, and periodic consistency checks. Teamwork GraphQL and SOAP APIs were not verified.
Teamwork supports webhook-style notifications for selected resources and events, but coverage is not universal. A notification may require a follow-up REST request for the complete object, and Martini can validate, deduplicate, retrieve, transform, and route the change. Polling should supplement webhook processing where coverage is incomplete.
Martini can paginate Teamwork collections, use updated timestamps or other supported change indicators, and store checkpoints for restartable synchronization. Stable Teamwork IDs should be retained as external keys, and dependent resources such as Companies, Projects, People, Tasks, and Milestones should be resolved in the correct order to support idempotent processing.
Yes. Martini can expose a controlled REST API that presents a stable enterprise-facing contract over Teamwork REST operations. The façade can centralize authentication, validation, mapping, business rules, error handling, and access controls while shielding consuming applications from Teamwork-specific details.
Related Martini documentation
API Workflows
Triggers and Mapping
Security
Connect Teamwork with your enterprise systems
Use Martini to build secure, maintainable Teamwork integrations across APIs, webhooks, scheduled workflows, files, and downstream business applications.