How to Integrate Systems That Have No API: Database, SOAP, File and Library-Level Options

Last updated: November 2026

A system without an API can still be integrated. The four main options are direct database integration, SOAP and older web services, vendor or internal libraries, and file-based exchange. Each method has different trade-offs in latency, reliability, security and maintenance. This guide explains how each one works, when to use it and how to reduce its risks. It also explains how integration platforms such as ZigiOps make these methods available without custom code, so systems without an API can be integrated in the same way as modern SaaS platforms.

"Does it have an API?" is usually the first question in any integration project. When the answer is no, the project often stops. The system is marked as unsupported, users keep copying data by hand, and the organization moves on to the next priority.

That reaction is understandable but unnecessary. Systems communicated with each other long before REST APIs became the default. Databases, SOAP services, libraries and files are all valid integration interfaces, and many of the most important enterprise systems still rely on them. The real question is not whether a system has an API, but how it stores and exposes its data.

Why so many systems still lack an API

  • Age. Applications built before the mid-2010s often predate REST conventions.
  • Internal development. In-house tools were usually built for users, not for other systems.
  • Vendor strategy. Some commercial products restrict APIs to premium editions or do not offer them at all.
  • Niche markets. Industry-specific software vendors may not have resources to build and maintain public APIs.
  • Security choices. Some systems are deliberately kept closed, with access only through the database or a client library.

Option 1: Direct database integration

Many applications store their data in relational databases such as Microsoft SQL Server, Oracle, PostgreSQL or MySQL. Integrating at the database level means reading data directly from the tables and, where appropriate, writing to them.

How it works

The integration tool connects to the database using a dedicated account, queries the relevant tables for new or changed records, and transforms the results for the target system. For write-back, it inserts or updates records, ideally through stored procedures or staging tables rather than directly into core tables.

When to use it

  • The application has no API but uses a well-structured relational database.
  • You need near real-time access to data.
  • The database schema is stable and reasonably documented.

Risks and how to manage them

  • Bypassing business logic. Writing directly to tables may skip validation the application normally performs. Prefer read access, staging tables or stored procedures for writes.
  • Schema changes. Application upgrades can change table structures. Keep mappings in a configurable tool, not in hard-coded queries.
  • Performance. Frequent queries can load the database. Use change-tracking columns, timestamps or database change data capture features and query efficiently.
  • Security. Use least-privilege accounts restricted to specific tables or views.

Option 2: SOAP and older web services

SOAP web services were the standard for enterprise integration in the 2000s, and many systems still expose them. ERP systems, older ITSM platforms, banking systems and government applications often provide SOAP interfaces.

How it works

A SOAP service is described by a WSDL file that defines its operations and data structures. The integration tool calls these operations, sending and receiving XML messages, usually over HTTPS.

When to use it

  • The system exposes SOAP services for the data you need.
  • You want to go through the application's business logic rather than its database.

Risks and how to manage them

  • Complex payloads. SOAP messages can be verbose and deeply nested. Choose a tool that handles XML mapping well.
  • Authentication variety. WS-Security, basic authentication and certificates are all common. Confirm support before starting.
  • Limited change detection. SOAP services may not offer "changed since" queries, so polling strategies need care.

Option 3: Libraries and SDKs

Some applications expose their functionality through client libraries, such as Java JAR files, .NET assemblies or native libraries. These are often used by the application's own client or by partners.

How it works

The integration platform loads the library and calls its functions to read or write data, in the same way a custom program would. This uses the application's own logic and validation.

When to use it

  • The vendor provides a library but no API.
  • Database access is not allowed or would bypass critical logic.

Risks and how to manage them

  • Version dependency. Libraries must match the application version. Plan for updates during upgrades.
  • Platform requirements. Libraries may require a specific runtime or operating system, which affects where the integration runs.
  • Licensing. Check whether library use is covered by your license.

Option 4: File-based exchange

Exporting and importing files, such as CSV, XML or fixed-width text, is the oldest integration method and still widely used.

How it works

One system writes a file to a shared location or SFTP server on a schedule. The integration tool picks it up, transforms it and loads it into the target system.

When to use it

  • No other access method exists.
  • Batch timing is acceptable, for example for nightly financial or reporting data.

Risks and how to manage them

  • Latency. Data is only as fresh as the last file.
  • Fragility. Format changes, missing files and partial transfers can break the flow silently.
  • Security. Files containing sensitive data must be encrypted, access-controlled and deleted after processing.
Comparison of integration methods for systems without an API
MethodLatencyUses application logicMain riskBest for
DatabaseNear real timeNoBypassing validation; schema changesDatabase-centric internal systems
SOAPNear real timeYesComplex payloads and authenticationOlder enterprise applications
LibraryNear real timeYesVersion and runtime dependencyVendor products with SDKs
FileBatchDepends on import processSilent failures, stale dataSystems with export only

How to choose the right method

  1. Ask the system owner what interfaces exist. Check for SOAP services, libraries, database access and export functions.
  2. Decide whether business logic must be respected. For writes, prefer SOAP or libraries. For reads, database access is often acceptable.
  3. Define latency requirements. Real-time incident or order flows rule out file exchange.
  4. Check security policies. Some organizations prohibit direct database access from integration tools; others prefer it to file transfers.
  5. Consider maintenance. Choose the method that is least likely to break during upgrades.

Combining methods in one integration

Methods can be combined. A common pattern reads changes from a database, because it offers reliable change detection, and writes updates back through SOAP services or a library, so the application's validation runs. Another pattern uses a database view created specifically for integration, which shields the integration from internal schema changes.

Detecting changes without an API

Synchronization depends on knowing what has changed since the last run. Modern APIs often provide "updated since" queries or webhooks. Systems without APIs need other techniques:

  • Timestamp columns. Many tables include a last-modified date. Querying records changed since the last successful run is simple and efficient.
  • Sequence or version numbers. Incrementing IDs or row versions allow the integration to pick up new or changed records reliably.
  • Database change data capture. Many databases offer built-in change tracking that records inserts, updates and deletes.
  • Triggers to staging tables. A database trigger can write changes to a dedicated table that the integration reads and clears.
  • Snapshot comparison. As a last resort, the integration compares current data with a previous snapshot. This is resource-intensive and should be limited to small datasets.

Whichever technique you use, make sure deletions are handled. Many change-detection approaches capture inserts and updates but miss deleted records, which can leave orphaned data in the target system.

Real-world scenarios

Legacy asset database to ITSM

An infrastructure team keeps hardware assets in an older SQL-based application. A read-only database view exposes assets with a last-modified timestamp, and the integration synchronizes them to the ITSM platform's configuration management database every few minutes.

SOAP-based ERP to service desk

An older ERP exposes purchase orders through SOAP services. When an IT hardware request is approved in the service desk, the integration creates a purchase requisition through the SOAP interface and returns the ERP order number to the ticket.

Vendor library for an industry application

A laboratory system offers a Java client library but no API. The integration platform uses the library to read instrument error events and create incidents in the ITSM platform, then writes resolution notes back through the same library.

File exports from a regional payroll tool

A payroll application can only export CSV files. A nightly file transfer updates employee cost centers in the ERP and HR systems. Real-time sync is not required, so file exchange is acceptable here.

The custom code trap

The traditional way to integrate systems without APIs is to write custom code: a script that queries a database, a program that calls a SOAP service, a job that parses a file. It works, but every script becomes another small system to maintain, secure and monitor. Over time, organizations accumulate dozens of such scripts, often undocumented and owned by people who have moved on.

A better approach is to use an integration platform that supports these methods natively. ZigiOps, for example, can integrate any system with any other through an API, SOAP, a database or a library. The system does not need an API at all. Once a connector exists, the integration is configured without code, with the same field mapping, conditions, bi-directional synchronization and logging used for mainstream platforms such as ServiceNow, Jira or Salesforce. ZigiOps typically builds new connectors in about three days.

Security checklist for non-API integrations

  • Use dedicated integration accounts with least-privilege access.
  • Prefer database views or staging tables over direct access to core tables.
  • Encrypt connections, including database and SOAP traffic.
  • Avoid persisting transferred data in the integration layer. ZigiOps does not store the data it transfers.
  • Log every read and write operation for auditing.
  • Include non-API integrations in regular access reviews and penetration tests.

Frequently asked questions

Can you integrate a system without an API?

Yes. Systems without an API can be integrated through direct database access, SOAP web services, libraries or SDKs, and file-based exchange.

Is direct database integration safe?

It can be, if you use least-privilege accounts, prefer read access or staging tables for writes, encrypt connections and monitor activity. Always confirm that it is allowed by the application vendor and your security policy.

What is the difference between SOAP and REST?

SOAP is a protocol that uses XML messages and formal contracts described in WSDL files. REST is an architectural style that typically uses JSON over HTTP. Both can be used for integration.

Is file-based integration still acceptable?

For batch use cases, yes. For real-time processes such as incident management or order status, database, SOAP or library methods are better choices.

Do I need developers to integrate systems without APIs?

Not necessarily. Integration platforms such as ZigiOps support database, SOAP and library connectivity without custom code.

How do you detect changes in a system without an API?

Common options are timestamp or change-tracking columns, database change data capture, polling with comparison, or triggers that write changes to a staging table.

How fast can a system without an API be connected?

With custom development, it often takes several weeks once design, coding, testing and security review are included. With a platform that already supports database, SOAP and library connectivity, the timeline is much shorter. ZigiOps, for example, typically delivers a new connector in about three days, after which the integration is configured without code.

Will integrating at the database level void vendor support?

For commercial products, it can. Check the vendor's support policy before writing to its database. Reading through views or using the vendor's own SOAP services or libraries is usually safer from a support perspective.

Key takeaways

  • No API does not mean no integration; databases, SOAP, libraries and files are all valid interfaces.
  • Choose the method based on available interfaces, business logic, latency and security requirements.
  • Combining methods, such as database reads and SOAP writes, often gives the best results.
  • Avoid accumulating custom scripts; use a platform that supports these methods natively.
  • ZigiOps integrates systems without an API through no-code configuration, without storing transferred data.