API, SOAP, Database or Library? Choosing the Right Integration Method for Every System
Last updated: November 2026
Every integration starts with one technical decision: how to reach each system. The main options are REST APIs, webhooks and events, SOAP web services, direct database access, libraries or SDKs, and file exchange. Each method differs in latency, reliability, security, maintenance effort and how well it respects the application's business logic. This guide compares all six side by side, gives a decision tree for choosing between them and explains how integration platforms such as ZigiOps let teams mix methods in one integration without writing code.
Integration discussions often jump straight to tools: which iPaaS, which connector, which app. But the more fundamental question is which interface each system offers and which one you should use. Two integrations between the same systems can behave very differently depending on whether they use an API, a database or a file. The method shapes how fresh data is, how failures show up, what security reviews ask and how much work future upgrades cause.
This guide is a neutral reference for architects, integration engineers and IT leaders who need to choose and justify integration methods across a mixed landscape of modern and older systems.
The goal is not to declare one method superior. Each has a place. The goal is to choose deliberately, document why, and avoid the common trap of declaring a system "impossible to integrate" simply because it lacks a REST API.
The six integration methods at a glance
| Method | Typical latency | Uses application logic | Change detection | Maintenance risk |
|---|---|---|---|---|
| REST API | Seconds to minutes | Yes | Polling or "updated since" queries | Low to medium (API versions) |
| Webhooks and events | Near real time | Yes | Pushed by source | Medium (delivery guarantees) |
| SOAP web services | Seconds to minutes | Yes | Usually polling | Low (stable contracts) |
| Database | Seconds to minutes | No | Timestamps, change tracking, triggers | Medium (schema changes) |
| Library or SDK | Seconds to minutes | Yes | Depends on library functions | Medium (version dependency) |
| File exchange | Hours (batch) | Depends on import process | New file per batch | High (silent failures) |
Method 1: REST APIs
REST APIs are the default for modern applications. They expose resources over HTTP, typically using JSON, and are protected by tokens or OAuth.
Choose REST when: the system offers a well-documented API that covers the data you need.
Watch for: rate limits, pagination, incomplete coverage of custom fields or objects, and API version deprecations. Many APIs do not expose every field visible in the user interface.
Method 2: Webhooks and events
Webhooks and event streams push changes from the source system to a listener as they happen. Many SaaS tools offer webhooks; some enterprise platforms publish events to message queues or event buses.
Choose events when: low latency matters, and the source reliably publishes the events you need.
Watch for: missed events if the listener is unavailable, limited payloads that require a follow-up API call, and ordering issues. Many robust integrations combine webhooks for speed with periodic polling for completeness.
Method 3: SOAP web services
SOAP services use XML messages defined in a WSDL contract. They remain common in ERP systems, older ITSM platforms, banking, insurance and public sector applications.
Choose SOAP when: the system exposes SOAP operations for the data you need, especially for writes that must pass through business logic.
Watch for: verbose and nested payloads, varied authentication schemes such as WS-Security or certificates, and limited support in tools built only for REST.
Method 4: Direct database access
Many applications, especially internally built ones, store data in relational databases without exposing an API. Integrations can read from and, carefully, write to these databases.
Choose database access when: no service interface exists, or you need efficient bulk reads with reliable change detection.
Watch for: bypassing application validation on writes, schema changes during upgrades, query load on production databases and vendor support policies. Use read-only views and staging tables to reduce risk.
Method 5: Libraries and SDKs
Some applications provide client libraries, such as Java or .NET assemblies, that expose their functions to other programs. These are common in specialized vendor software and internal platforms.
Choose libraries when: no API exists but the library offers the operations you need, with the application's validation built in.
Watch for: matching library versions to application versions, runtime and operating system requirements, and licensing terms.
Method 6: File exchange
Files, such as CSV, XML or fixed-width exports placed on SFTP servers or shared folders, remain a fallback for systems with no other interface.
Choose files when: nothing else exists and batch timing is acceptable, such as nightly financial or reporting data.
Watch for: stale data, format changes, partial files and missing alerts. Encrypt files and delete them after processing.
A decision tree for choosing a method
- Does the system publish events for the changes you need? If yes, use events for speed, combined with API polling for completeness.
- Does it offer a REST API covering your data? If yes, use REST.
- Does it offer SOAP services covering your data? If yes, use SOAP, particularly for writes.
- Does it provide a library or SDK? If yes, use the library when writes must respect business logic.
- Is the database accessible and allowed? If yes, use read-only views for reads and staging tables or another method for writes.
- Only files remain? Use files for batch flows, and plan to replace them if real-time needs grow.
The tree favors methods that use the application's own logic and provide reliable change detection, while keeping database and file methods available rather than declaring a system "unsupported".
Mixing methods within one integration
The best integrations often combine methods. Common combinations include:
- Webhooks plus API: a webhook signals a change, and the integration fetches full details through the API.
- Database reads plus SOAP writes: changes are detected efficiently in the database, and updates are written through SOAP so validation runs.
- Database reads plus library writes: similar to the above, using a vendor library for updates.
- API plus files: real-time operational data through the API, with nightly files for large historical or financial datasets.
Mixing methods requires an integration platform that supports all of them in the same configuration. ZigiOps, for example, can integrate any system with any other through an API, SOAP, a database or a library, so a single integration can read from a database and write to a REST API, or read from a SOAP service and write through a library, without custom code.
Security considerations by method
| Method | Key controls |
|---|---|
| REST API | OAuth or scoped tokens, TLS, token rotation, least-privilege service accounts |
| Webhooks and events | Signature validation, TLS, allow-listing, replay protection |
| SOAP | WS-Security or certificate authentication, TLS, restricted operations |
| Database | Read-only accounts on views, encrypted connections, network restrictions, query auditing |
| Library | Dedicated accounts, controlled runtime environment, version management |
| Files | Encryption at rest and in transit, access control, automatic deletion |
Across all methods, minimize what the integration layer stores. ZigiOps does not store the data it transfers, which reduces exposure regardless of the method used.
Performance and reliability considerations
- Polling frequency. Frequent polling reduces latency but increases load and API consumption. Use change detection to keep queries light.
- Batching. Group updates where the target supports bulk operations.
- Retries and idempotency. Design writes so that retries do not create duplicates.
- Backpressure. During event storms, queue or throttle updates rather than overwhelming the target.
- Monitoring. Track error rates and sync delays per method; file and database methods especially need alerts for missing data.
How method choice affects maintenance
The method you choose today determines the work you will do during every upgrade. REST APIs change through versioning, usually with notice. SOAP contracts tend to be very stable. Database schemas can change with any application release, so integrations that rely on them should use views that the application team commits to maintaining. Libraries must be updated in step with the application. Files change format when someone edits an export job, often without warning.
Keeping integration logic in a configurable platform rather than in code reduces the effort of these changes. When a field moves or a status is renamed, a mapping update is enough. ZigiOps keeps mappings, conditions and connection settings in configuration, so method-specific changes do not require redevelopment.
Common mistakes when choosing integration methods
- Assuming REST is always available. Integration plans built on that assumption stall when they reach older or internal systems.
- Building an API just to integrate. Creating a new API layer can take months. If the system already exposes SOAP, a database or a library, use it.
- Writing directly into application tables. Database writes that bypass validation can corrupt data. Use staging tables or a method that runs the application's logic.
- Relying only on webhooks. Webhooks can be missed during outages. Add periodic reconciliation through an API or database read.
- Treating files as real-time. Files are batch by nature. If a process needs current data, choose a different method.
- Choosing per project, not per landscape. When each project picks its own method and tool, the organization ends up with inconsistent security and monitoring.
Documenting your method choices
For every integrated system, record the method used, why it was chosen, which account it uses, what data it can reach and who approved it. This short record helps security reviews, speeds up troubleshooting and makes it easier to change methods later, for example when a legacy system finally receives a REST API. A simple register with these fields for every system is often enough.
Example: one integration, three methods
A utility company connects an internally built field operations system, an older SOAP-based ERP and ServiceNow.
- New maintenance faults are read from the field operations database through a read-only view.
- Each fault creates a ServiceNow incident through the REST API.
- When spare parts are needed, the integration creates a reservation in the ERP through its SOAP service.
- ERP reservation status and ServiceNow incident status are written back to a staging table in the field operations database.
Three systems, three methods, one integration flow. Before, each link was a separate script; with a platform supporting all three methods, the flow is configured and monitored in one place.
Frequently asked questions
What is the best integration method?
There is no single best method. REST APIs and events suit modern systems; SOAP, databases and libraries suit older or internal systems; files suit batch flows. Choose based on available interfaces, latency, business logic and security.
Is SOAP outdated?
SOAP is older than REST but still widely used and reliable, especially in enterprise and regulated environments. It remains a valid integration method.
When is direct database integration acceptable?
When no service interface exists, access is allowed by the vendor and security policy, and you use least-privilege accounts, read-only views for reads and controlled mechanisms for writes.
What is the difference between a webhook and an API?
An API is called by the integration to request or send data. A webhook is a call made by the source system to notify the integration of a change.
Can one integration use several methods?
Yes. Combining methods, such as database reads and SOAP writes, is common. Platforms such as ZigiOps support mixing methods without code.
How do I integrate a system that only offers file exports?
Schedule exports to a secure location, process them with validation and alerts, and plan to move to a database, SOAP or library method if real-time needs arise.
Should I switch methods when a legacy system gets a REST API?
Usually yes, if the new API covers the needed data and is stable. Keeping mappings in a configurable platform makes the switch a connection change rather than a rebuild.
Key takeaways
- The integration method shapes latency, reliability, security and maintenance more than the tool brand.
- REST, events, SOAP, databases, libraries and files are all valid; choose based on interfaces and requirements.
- Prefer methods that use application logic for writes, and reliable change detection for reads.
- Combine methods where it improves reliability or performance.
- ZigiOps supports API, SOAP, database and library connectivity in one no-code platform, so no system needs to be left out.