.png)
Planful Integration Guide
Integrate Planful financial planning, budgeting, forecasting, consolidation, and reporting data with enterprise systems through APIs, batch loads, files, and orchestrated workflows.
Planful integration options at a glance
Planful supports API-based integration and recurring financial data-load processes, while the exact REST resources, authentication flow, batch behavior, and tenant configuration must be confirmed for each environment. Structured file imports can support financial and operational data exchanges, particularly for larger planning loads. Webhook-style notifications or callbacks may be available in selected products or configurations, but a general-purpose event framework was not verified. Martini can consume documented Planful APIs, schedule and orchestrate workflows, transform financial dimensions, submit controlled batches or files, expose normalized REST endpoints, and route failures for review without connecting directly to Planful’s managed database.
| Integration point | Supported by Planful? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Limited | Use documented Planful platform or integration endpoints to exchange financial, planning, reporting, or metadata data. Exact resources, operations, request formats, and tenant requirements must be confirmed. | Martini can consume REST APIs, authenticate using configured credentials, process JSON responses, apply validation and mappings, and expose REST APIs for normalized Planful services. |
| Bulk / async / batch APIs | Limited | Recurring financial data loads and larger transfers can use batch, asynchronous, or job-based processes where enabled by the customer’s Planful environment. | Martini can split workloads into controlled batches, submit loads, track job status where an endpoint exists, reconcile results, and retry transient failures. |
| File import/export | Limited | Structured CSV or other tabular files can support financial-data imports and recurring integration processes. Templates, delivery methods, and file formats require confirmation. | Martini can generate, validate, transform, and deliver files through the approved exchange process, while recording source batches and load outcomes. |
| Webhooks / outbound callbacks | Limited | Planful may provide notifications or callbacks in selected products or configurations, but a general-purpose webhook framework and complete event catalog were not verified. | Martini can receive documented callback requests or webhook-style notifications, then retrieve current data and invoke follow-up workflows; event coverage must be confirmed first. |
| Authentication | Limited | Secure access may use OAuth 2.0, API or integration credentials, tenant-specific endpoints, and Planful role and permission controls. Exact token flows and scopes require verification. | Martini stores credentials and tokens in environment configuration or secrets and uses them in API workflows without embedding sensitive values in mappings. |
| GraphQL APIs | Not confirmed | No official Planful GraphQL API documentation was verified, so GraphQL should not be assumed for Planful integration. | Martini can consume GraphQL generally, but a Planful GraphQL implementation should only be designed after tenant-specific confirmation. |
| SOAP APIs | Not confirmed | No current official Planful SOAP interface was verified. Older Host Analytics references should not be treated as confirmation of a current SOAP service. | Martini can consume SOAP services generally, but SOAP should not be selected for Planful without current endpoint documentation. |
| Database access | No | Direct access to Planful’s managed application database was not verified and should not be used as an integration dependency. | Martini should use documented APIs, supported exports, or approved file processes instead of connecting to Planful’s internal database. |
How Planful exposes data and business events
Planful REST APIs
Planful provides API-based platform and integration capabilities, but the exact REST resources, operations, authentication flow, and payload formats depend on the customer’s tenant and provisioned interface.
Martini implementation pattern
Martini implementation pattern: Martini authenticates against the confirmed Planful endpoint, calls the required resource, validates the response, maps Planful dimensions into a canonical model, and sends the result to the target system or continues the workflow.
Implementation sequence
Planful Batch and Data Loads
Planful supports recurring financial data integration and data-load patterns. Large transfers may use batches, files, asynchronous jobs, or load-status processes whose exact behavior must be confirmed.
Martini implementation pattern
Martini implementation pattern: Martini assembles a validated batch or structured file, submits it through the approved Planful mechanism, tracks the load or response status when available, reconciles totals, and routes failures for correction or retry.
Implementation sequence
Planful Webhook-Style Notifications
Planful may support callbacks or event-style notifications in selected products or configurations, but a general-purpose webhook model and complete event catalog were not verified.
Martini implementation pattern
Martini implementation pattern: When a documented callback is available, Martini receives the notification through a controlled API, verifies the request, retrieves the current Planful resource if required, and processes the event idempotently. Scheduled polling remains an alternative when callbacks are unavailable.
Implementation sequence
Planful File Imports and Exports
Structured CSV or other tabular files can be used for financial-data imports and recurring integration processes, subject to Planful templates, delivery methods, and tenant configuration.
Martini implementation pattern
Martini implementation pattern: Martini extracts source data, transforms it into the approved Planful template, validates required columns and member values, delivers the file through the supported process, and tracks acceptance or rejection results.
Implementation sequence
Common Planful integration patterns
Pattern 1: Load general-ledger actuals into Planful
When to use this pattern
Use this pattern when actual financial data from an ERP or accounting system must be loaded into Planful on a scheduled cadence. It supports account and entity mapping, fiscal-period conversion, currency handling, duplicate-load prevention, and batch-level reconciliation.
Integration direction
Example Mapping
| Planful Field | Canonical Field | Target Field |
|---|---|---|
| accountCode | account.code | Account |
| subsidiary | entity.code | Entity |
| postingPeriod | fiscalPeriod | Time period |
| amount | signedAmount | Value |
Martini implementation pattern
A scheduled Martini workflow retrieves approved actuals, validates the source batch and required Planful members, converts accounts, entities, periods, currencies, and sign conventions, then submits a supported Planful API or file load. It stores the source batch identifier, tracks acceptance or load status, reconciles totals, and retries only transient failures.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- validation
- error handling
Pattern 2: Publish Planful budgets and forecasts to Snowflake
When to use this pattern
Use this pattern when approved budgets, forecasts, or reporting data must be centralized for enterprise analytics. The workflow can preserve scenario, period, dimension, and extraction metadata for auditability.
Integration direction
Example Mapping
| Planful Field | Canonical Field | Target Field |
|---|---|---|
| Scenario | planning.version | scenario_key |
| Entity | organization.code | entity_key |
| Account | account.code | account_key |
| Value | planning.amount | amount |
Martini implementation pattern
Martini retrieves available Planful data through a documented endpoint or supported export, handles pagination or batch responses, normalizes dimensions and scenario identifiers, and writes curated rows to Snowflake. It records extraction timestamps and transformation versions and supports reruns using a defined period or scenario key.
Martini capabilities used
- workflows
- API consumption
- data mapping
- JSON handling
- business rules
- database integration
- error handling
Pattern 3: Bring CRM pipeline data into Planful forecasting
When to use this pattern
Use this pattern when opportunity, bookings, or revenue-related data from Salesforce must inform Planful forecasts. It is useful when fiscal calendars, currencies, product mappings, and forecast-stage rules differ between the systems.
Integration direction
Example Mapping
| Planful Field | Canonical Field | Target Field |
|---|---|---|
| CloseDate | forecast.period | Time period |
| Amount | pipeline.value | Forecast value |
| StageName | forecast.stage | Scenario or forecast classification |
| AccountId | customer.account.reference | Entity or planning dimension |
Martini implementation pattern
Martini retrieves eligible Salesforce opportunities, applies closed-won and forecast-stage rules, converts dates to Planful fiscal periods, maps currencies and planning dimensions, and submits the resulting budget or forecast load through the confirmed Planful interface. Duplicate opportunity handling, late changes, validation failures, and rejected batches are routed through explicit workflow branches.
Martini capabilities used
- API consumption
- workflows
- data mapping
- business rules
- validation
- scheduling
- error handling
Pattern 4: Expose a controlled Planful reporting façade
When to use this pattern
Use this pattern when downstream applications need selected Planful report or planning data without receiving direct tenant credentials. Availability depends on the Planful API or export capability enabled for the customer.
Integration direction
Example Mapping
| Planful Field | Canonical Field | Target Field |
|---|---|---|
| reportIdentifier | report.id | Planful report resource |
| scenario | planning.version | Scenario filter |
| entity | organization.code | Entity filter |
| period | fiscalPeriod | Time period filter |
Martini implementation pattern
Martini exposes a secured REST API that validates caller authorization and request parameters, calls the confirmed Planful reporting or planning endpoint, transforms the response into a stable contract, and applies caching, logging, and error handling. The façade isolates Planful-specific schemas and permissions from consuming applications.
Martini capabilities used
- API exposure
- workflows
- authentication and authorization
- data mapping
- business rules
- error handling
- monitoring
Applications commonly integrated with Planful
Planful is commonly positioned alongside finance, operational, and analytics applications. These integrations typically move actuals, master data, pipeline information, budgets, forecasts, or reporting outputs through documented APIs, supported file processes, or scheduled workflows. The following examples are architectural patterns rather than claims of native Planful connectors.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Bring opportunity, bookings, pipeline, and account information into revenue planning and forecasting. | Salesforce → Martini → Planful | Martini schedules or receives source data, maps Salesforce pipeline stages and dates to Planful Accounts, Entities, periods, and Scenarios, applies forecast rules, and submits an approved API or file-based load with reconciliation and retry handling. |
| NetSuite | Load general-ledger actuals, subsidiaries, accounts, currencies, and financial dimensions into Planful. | NetSuite → Martini → Planful | A Martini workflow retrieves NetSuite financial data, converts account and entity structures to the Planful model, validates fiscal periods and signs, submits a controlled batch or file load, and records load status and reconciliation totals. |
| Workday | Synchronize organizational structures, workforce-related planning inputs, and financial information used in budgets and forecasts. | Workday → Martini → Planful | Martini consumes approved Workday data, maps organizations and planning attributes to Planful Entities and dimensions, validates member values, and sends the result through the customer’s confirmed Planful interface. |
| SAP S/4HANA | Transfer actuals, chart-of-accounts data, cost centers, entities, and other finance data for planning and reporting. | SAP S/4HANA → Martini → Planful | Martini orchestrates extraction, fiscal-calendar conversion, account and cost-center mapping, batch validation, and Planful submission while isolating transient API or load-job failures for retry. |
| Oracle Fusion Cloud ERP | Load actuals and master data into Planful and distribute approved planning outputs to finance reporting processes. | Oracle Fusion Cloud ERP → Martini → Planful | Martini retrieves selected Oracle finance data, applies currency, entity, scenario, and period rules, delivers it to Planful through a documented API or file process, and can expose normalized results to downstream applications. |
| Microsoft Dynamics 365 Finance | Synchronize ledger activity, entities, accounts, and planning inputs with Planful. | Microsoft Dynamics 365 Finance → Martini → Planful | A scheduled Martini workflow extracts Dynamics finance data, validates required Planful members, transforms the payload into the configured Planful load shape, and tracks source batch identifiers and accepted results. |
| Snowflake | Centralize Planful planning and reporting data with operational and financial data for enterprise analytics. | Planful → Martini → Snowflake | Martini retrieves available Planful planning or report data through documented APIs or exports, normalizes dimensions and scenario metadata, and writes curated data to Snowflake while retaining extraction and transformation metadata. |
| Anaplan | Exchange planning or operational-model outputs when organizations use both platforms for different planning domains. | Anaplan → Martini → Planful | Martini coordinates an agreed system-of-record direction, maps model dimensions and planning versions, validates period and scenario alignment, and transfers data through each platform’s confirmed API or supported file mechanism. |
How to build a Planful integration in Martini
Objective
Establish tenant-specific Planful connectivity without placing credentials or environment values in workflow logic.
Instructions in Martini
- Confirm the Planful endpoint, tenant, credential type, permissions, and supported API or file process
- Store credentials, tokens, base URLs, and environment values as Martini configuration or secrets
- Test authentication and access to the required Accounts, Entities, Scenarios, periods, or reports
Objective
Select a trigger that matches Planful’s confirmed integration behavior and the required data freshness.
Instructions in Martini
- Use a scheduler for recurring extraction or financial loads
- Use a documented callback only when Planful event coverage is confirmed
- Use an API endpoint when a source application needs to initiate the workflow
Objective
Acquire Planful or source-system data in a controlled manner that supports pagination, batching, and traceability.
Instructions in Martini
- Call the documented REST resource or receive the approved file or callback
- Handle pagination, response limits, and asynchronous load status where applicable
- Assign a source batch or delivery identifier to each integration run
Objective
Coordinate extraction, transformation, validation, submission, reconciliation, and downstream delivery as a maintainable Martini workflow.
Instructions in Martini
- Separate retrieval, mapping, validation, submission, and reconciliation stages
- Branch authentication, validation, business-rule, and transient service errors
- Persist checkpoints and load identifiers needed for recovery or reprocessing
Objective
Align Planful’s configurable financial model with the source or target system’s data structures.
Instructions in Martini
- Map Accounts, Entities, Scenarios, Time periods, currencies, and custom dimensions
- Convert fiscal calendars, signs, codes, and naming conventions explicitly
- Validate required members before writing data to Planful or downstream systems
Objective
Protect financial integrity by enforcing business rules and preventing duplicate or invalid loads.
Instructions in Martini
- Apply scenario, period, currency, and eligibility rules
- Use source batch identifiers and idempotency controls where supported
- Reconcile record counts and signed totals before marking a run successful
Common Planful data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Accounts | Represent general-ledger and planning accounts used for reporting, budgeting, forecasting, and consolidation. | NetSuite, SAP S/4HANA, Oracle Fusion Cloud ERP, Snowflake | Martini maps account codes, names, hierarchies, and sign conventions, validates membership, and includes account context in batch reconciliation. |
| Entities | Represent legal, organizational, departmental, or operating units used to segment financial data. | Workday, SAP S/4HANA, Microsoft Dynamics 365 Finance, Snowflake | Martini aligns source organizations with Planful Entities, validates hierarchy and permissions, and routes unmapped members for review. |
| Scenarios | Represent Actual, Budget, Forecast, and other planning versions. | Salesforce, Anaplan, Snowflake, reporting platforms | Martini applies scenario-selection rules, preserves source and Planful version identifiers, and prevents data from being loaded into the wrong planning context. |
| Time periods | Represent fiscal years, quarters, months, adjustment periods, and forecast horizons. | ERP systems, Salesforce, Snowflake, reporting platforms | Martini converts source dates to the configured Planful fiscal calendar and validates period availability before submission. |
| Reports | Provide financial or management reporting outputs for downstream distribution and analysis. | Snowflake, reporting platforms, finance collaboration processes | Martini can retrieve report outputs when the tenant exposes a documented API or export capability, then normalize and distribute the result. |
| Budgets and forecasts | Contain assumptions, targets, allocations, and forecast values used in financial planning. | Salesforce, Anaplan, Snowflake, ERP systems | Martini maps dimensions, currencies, periods, and scenario values, applies business rules, and supports controlled loads with reconciliation. |
Authentication and security considerations
Tenant-specific access
Planful endpoints, credentials, environments, permissions, and enabled features can vary by tenant. Confirm the required authentication flow, token endpoint, scopes, integration-user permissions, and access to financial dimensions before implementation.
Protect financial data
- Store Planful credentials, tokens, base URLs, and environment identifiers in Martini configuration or managed secrets.
- Apply least-privilege Planful roles and restrict access to required Accounts, Entities, Scenarios, periods, and reports.
- Expose only controlled Martini APIs to downstream applications and enforce authentication and authorization at the boundary.
Operational considerations for Planful integrations
Volume and rate control
Confirm Planful page sizes, request limits, batch restrictions, asynchronous behavior, and load-status endpoints. Use controlled concurrency, pagination, batching, and retry backoff rather than assuming one response contains a complete financial dataset.
Financial integrity
- Use source batch identifiers, scenario and period keys, watermarks, and reconciliation totals to support safe reruns.
- Map fiscal calendars, currencies, signs, Accounts, Entities, custom dimensions, and scenario names explicitly.
- Validate Planful model members and detect renamed, missing, or newly added dimensions before submission.
- Separate authentication, validation, schema, rate-limit, transient service, and business-rule errors for appropriate handling.
Testing and auditability
Test representative actuals, budgets, forecasts, corrections, rejected rows, partial loads, and reruns. Retain source identifiers, Planful load or report identifiers, record counts, totals, transformation versions, and retry history.
Why use Martini instead of scripts or point-to-point integrations?
Maintainable orchestration
Scripts and point-to-point interfaces often combine credentials, mappings, scheduling, retries, and business rules in code that is difficult to govern. Martini separates these concerns into workflows, APIs, configuration, mappings, and reusable integration logic.
Adapt to Planful models
Planful dimensions and enabled interfaces vary by tenant. Martini can apply explicit mappings and validation for Accounts, Entities, Scenarios, periods, currencies, and custom dimensions while isolating tenant-specific configuration from the workflow design.
Operate with control
- Coordinate API calls, file loads, batch jobs, and downstream writes in one workflow.
- Provide controlled retries, error routing, reconciliation, and monitoring for financial processes.
- Expose stable APIs so consuming applications do not depend directly on Planful-specific schemas or credentials.
Frequently asked questions
Planful can be integrated through its platform and integration APIs, recurring financial data-load processes, and structured file imports or exports where enabled. The exact REST resources, authentication, batch behavior, and tenant capabilities should be confirmed for the customer environment.
Yes. Martini can integrate with Planful by consuming confirmed Planful REST endpoints, orchestrating batch or file-based data loads, applying financial mappings and validation, and exposing controlled APIs for downstream applications. No native Martini Planful connector is documented in the supplied materials.
No. A dedicated Planful connector is not required. Martini can use Planful’s confirmed native APIs, supported file and data-load processes, authentication methods, and any tenant-specific callbacks that are documented and enabled.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Planful. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Planful, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
For new integrations, use the customer’s documented Planful REST or platform interface when it supports the required operation. For large financial transfers, use the supported batch, asynchronous, or structured file-load process. GraphQL and current SOAP support were not confirmed, and direct database access should not be assumed.
A general-purpose Planful webhook framework covering all financial changes was not verified. Callbacks or event-style notifications may be available in selected products or configurations, but Accounts, Entities, Budgets, Forecasts, and Reports should not be assumed to emit webhook events without tenant-specific confirmation.
Martini can run scheduled API extraction, polling, batch submission, or supported file exchange workflows. It can map Accounts, Entities, Scenarios, periods, currencies, and custom dimensions, preserve watermarks or batch identifiers when available, and use full-period processing when incremental change tracking is not provided.
Martini can classify authentication, validation, schema, rate-limit, network, and business-rule failures, then route or retry them according to the workflow design. Financial loads should use source batch identifiers, idempotency or replacement rules where supported, load-status tracking, and reconciliation to prevent duplicate values.
Related Martini documentation
Workflows
Planful integration with Martini
Connect Planful to finance, operational, and analytics systems through governed APIs, data-load workflows, structured files, and reusable integration logic with Martini.