What are the ways to integrate with 1C?
1C:Enterprise is a platform, and it ships several built-in integration mechanisms. The platform documentation and the 1C developer network describe them as: the standard OData interface, custom HTTP services, SOAP web services, exchange plans with XML messages, file import and export, the EnterpriseData format, COM connections, and external data sources for reaching other databases.
They differ in one main way: who defines the contract. OData is generated by the platform from the configuration. HTTP and web services are written by a 1C developer, so the contract is yours. Exchange plans and EnterpriseData are 1C-to-1C style mechanisms with a fixed format. Files are the lowest common denominator when nothing else is possible.
Before choosing, write down three facts: which 1C configuration and platform version the client runs, whether it is on-premises or in a cloud, and who can change the configuration. The last one decides more than any technical preference, because a custom HTTP service means a 1C developer must deploy code into the client's base.
Standard OData interface: fast start, limited control
1C can generate a REST-style interface automatically, based on the OData protocol (check the platform version and supported formats in the documentation for your release). You publish the infobase to a web server from Designer with the standard OData option enabled, and the objects selected for exposure become available through that interface.
The strength is speed: reading catalogs, documents and registers, and creating or updating records with GET, POST, PATCH and DELETE, without writing code on the 1C side. The weakness is that the contract mirrors the configuration's internal structure. Your integration then depends on object names, reference keys and attributes that the accountants' configuration may change in the next update.
OData suits read-heavy scenarios: pulling a price list, stock balances or a customer list into a website or a dashboard. For writing complex documents (an order with several posting steps), it is usually the wrong layer, because you bypass the business logic that a 1C developer would put into a handler.
- Good for: reading catalogs and balances, simple creation of reference data, prototypes.
- Careful with: posting documents, anything with business rules, anything you expect to survive a configuration upgrade unchanged.
- Cost: publishing needs a web server and a decision about which objects are exposed.
HTTP services and web services: a contract you control
HTTP services are native to 1C: a developer adds an HTTP service to the configuration, defines URL templates, binds each template to an HTTP method and writes a handler in the 1C language. The handler receives the request and builds the response. This is the closest thing to a normal backend API inside 1C.
SOAP web services are the older sibling. They still make sense when the other side already speaks SOAP or needs a WSDL. For a new integration written in Go, Node or Python, JSON over an HTTP service is easier to test and debug.
The main advantage is a stable contract. You can expose one operation, such as create an order for a customer, and the 1C handler runs the real business logic and returns a clear error. Ask the 1C developer whether the service can live in a configuration extension, since that affects how it survives upgrades of the base configuration. Design the contract like any integration API: versioned, with idempotent writes. See API design for integrations and API idempotency and retries.
- Good for: orders from a website, status updates, any write that must go through business logic.
- Needs: a 1C developer on the client's side or ours, and a deployment path to the production base.
- Plan for: authentication, timeouts, and the fact that 1C servers are not built for thousands of parallel requests.
EnterpriseData and file exchange: when systems swap batches
EnterpriseData is a business-oriented XML format built on XDTO. Instead of each configuration learning every other configuration, each one converts to and from the common format. It can be exchanged through a directory, FTP, a web service or email, and the full variant has acknowledgments. Standard exchanges between 1C products, such as Accounting and Trade Management, use it.
For a non-1C system, EnterpriseData is a heavy dependency: you must produce and parse a large schema, and extending it for custom fields requires changes on both sides. Use it when the other side is also a 1C product or already supports it.
Plain file exchange (CSV, XML, JSON through ReadXML, WriteXML or the JSON writer, moved over HTTP, FTP or email) is the fallback. It works with old configurations and locked-down servers. The price is latency, no real-time answers, and the need to handle half-written files, duplicates and encoding. Treat each file as a message with an ID, a checksum and a processed marker.
Why not read the 1C database directly?
It is tempting: the data sits in SQL tables, so why not query them? In practice 1C stores objects in generated tables with obscure names, splits fields across tables, and changes structure between versions. A query that works today breaks after the next platform update.
Writing is worse. Direct inserts skip posting logic, access control, registers and movements, so the base stays internally inconsistent. Sources in the 1C community also point out that direct access to the database conflicts with the vendor's license terms; we could not find the exact wording, so check the current agreement for your case.
If you need analytics or a data warehouse, export through OData, an HTTP service or a scheduled exchange, and keep the copy in your own Postgres. If the only option left is reading tables, treat it as a read-only emergency measure, on a replica, with no writes.
How to choose: a short decision list
Start from the data flow, not from the technology. Ask which side is the source of truth for each entity, how fresh the data must be, and what happens when a request fails.
Then match the pattern.
- Read-only data to a website or dashboard, client will not change 1C: OData, with a cache on your side.
- Orders or payments written into 1C with business rules: an HTTP service in a configuration extension, called through a queue.
- Two 1C products synchronised: the standard exchange with EnterpriseData, not a custom build.
- Legacy or restricted base, nightly batches are fine: file exchange with IDs and checksums.
- Unknown platform version or no developer access: start with files or OData and plan the move later.
- Never: direct writes to SQL tables.
1C with a website, Bitrix and payment systems
A website needs three things from 1C: the catalog with prices and balances, a way to send orders, and order statuses back. Catalog and balances are a read flow, so OData or a scheduled export fits. Orders are a write flow, so an HTTP service with a clear error contract is safer. Do not call 1C on every page view: copy the data into your own database and refresh it in the background. See system integration with API and webhooks and background jobs and queues in Go.
For a Bitrix site, the standard route is the exchange built into Bitrix. It uses the CommerceML XML format and covers catalog, customers and orders. It covers a typical shop. It struggles with personal prices, unusual fields and multi-warehouse logic, which is when teams add a REST API or an intermediary service. Verify the exact parameters and the exchange script settings in the official Bitrix documentation for your version.
For payments, the usual pattern is not to connect 1C to the payment provider directly. The site or a small service receives the provider's webhook, verifies the signature, records the payment once and then passes the result to 1C through its HTTP service. That keeps secrets and retries outside 1C. Read webhook security and signatures and check the provider's own documentation for event types. For marketplaces, see 1C and marketplace integration.
When you do not need custom 1C integration, and when to hire a contractor
You may not need custom work if a ready connector already covers your case. Standard Bitrix exchange for a simple shop, or an official module from the marketplace or payment provider, is cheaper than anything built from scratch. Also skip it if you move a few records a month: a manual export may be the honest answer.
Hire a contractor when the flow writes into 1C, when several systems (site, CRM, marketplace, payments) must stay consistent, or when failures cost money: lost orders, double charges, wrong balances. This is queue, retry and monitoring work as much as 1C work, and it is where integration projects usually fail. A good contractor will ask who owns the 1C configuration, request a test base, and propose a contract and a reconciliation report before writing code.
If the problem sits inside 1C itself, such as report logic or configuration changes, you need a 1C specialist, not an integration studio. The best setup is two roles: one on the 1C side, one on the integration side, with a single written contract between them. For CRM and ERP flows, see CRM and ERP integration.