An online store or a services website almost always runs into the same question sooner or later: how to connect it to 1C. Products, prices and stock live in the accounting system, orders from the website must end up in the same place, and a manager should not have to retype data by hand. The task itself is usually clear; who should do it is not. The web studio says 1C is not their area. The 1C programmer replies that the website is not their system. As a result, the client ends up between two contractors, each convinced the problem is on the other side.
This situation is familiar to many: the integration is “more or less done”, but stock levels diverge, orders get lost, and nobody can fix it because it is unclear whose responsibility it is. In this article we look at what an integration between a website and 1C consists of, what each contractor should do, when one is enough, when you need both, and how to organise the work so the client does not become a translator between two teams.
Why the “who does it” question arises at all
Integrating a website with 1C sits at the junction of two technology worlds. The website runs on web technologies, while 1C is a separate platform with its own programming language, its own logic and a distinct ecosystem of specialists. People who know one side well usually do not know the other in depth: a web developer has a poor grasp of standard 1C configurations and reference books, and a 1C programmer is unfamiliar with how an online store works and with the load on a website.
That is why “handing the whole task to one person” is not as simple as it seems. A contractor who takes on the integration as a whole must either have strong competence in both areas or bring in a partner. It is important for the client to understand this in advance and choose a working model deliberately, rather than discovering the split of responsibilities mid-project, when deadlines and budget are tight.
What a website–1C integration consists of
To understand who does what, you need to see the structure of the work. It is convenient to split the integration into three layers. The first is the data and rules inside 1C itself: which products, prices and stock to send to the website, how to receive orders from it, how to match customers and counterparties, which warehouses and price types to take into account. The second is the exchange channel: the way data travels between the systems. The third is the website side: how to receive the data, show it in the storefront, create an order and send it back.
The exchange is usually built in one of several ways:
- the standard XML-based data exchange format between 1C and websites, supported by many e-commerce platforms and ready-made modules;
- exchange through programming interfaces: services published by 1C itself (HTTP services, the standard OData interface in supported platform versions) and the website API;
- file exchange on a schedule.
The choice depends on the 1C platform version, the configuration in use, the website's capabilities and the required speed of data updates. We described in detail how integrations with external systems work and what risks they carry in our article on API integrations.
What the 1C programmer does
The 1C programmer is responsible for everything that happens inside the accounting system. They set up or extend the data export: they define which products, attributes, prices and stock go to the website, by what rules they are selected and in what form they are produced. They implement order intake from the website: create “Customer order” or similar documents, find or create the counterparty, link products to the item catalogue, and correctly fill in warehouses, the organisation, price type and other required fields.
They are also responsible for making sure changes in 1C do not break the exchange: when the configuration is customised, the structure of reference books changes or the platform is updated, the exchange must be checked and adapted. They also set up the exchange schedule, error handling on the 1C side and logging. Their role matters most when the configuration is heavily customised for the business: in customised configurations the standard exchange mechanisms often stop working “out of the box”, and you need someone who understands the internals of your particular database. They know where the needed data is stored in your database and which business rules must not be broken so as not to damage the accounting.
What the web studio does
The web studio is responsible for the website and everything connected to it. It implements receiving data from 1C: loading the catalogue, prices and stock, displaying them on the site and updating them when they change. It ensures orders are sent to 1C in the required format, that the cart and checkout work correctly, that delivery and payment are accounted for, and that order statuses are passed back to the website so the customer sees up-to-date information.
Load and reliability matter just as much: the studio makes sure the website handles large data updates without slowing down for visitors, that leads are retried rather than lost when 1C or the internet fails, and that errors get noticed. This part is no different from the principles of reliable integration we discussed in the article on lost leads: save data until confirmed, retry sending, notify about errors. It is the studio that decides how the data from 1C will look and work in the storefront, search and filters, and that determines how much the customer actually sees and buys.
Three models: who fits when
Web studio only
This works when you have a standard, lightly customised 1C configuration and the website platform supports the standard exchange or a proven ready-made module exists. In that case setup mostly comes down to connecting and configuring, and a studio with experience in such projects can manage on its own, bringing in 1C consultation on specific points. This is the fastest and cheapest option, but it is risky if the database is non-standard or the studio has no experience with 1C.
1C programmer only
This sometimes occurs when the website is simple and the main complexity lies in 1C: for example, data must be exported by complex rules from a heavily customised configuration, while the website side accepts it in a standard way. However, the website suffers here: without a web developer it is hard to ensure performance under load, a convenient storefront and error handling. This model is rarely sufficient for a full online store.
Both sides
The most common and generally the most reliable option for projects where both the website and 1C are non-trivial. The 1C programmer handles their part, the studio handles theirs, and a clear exchange agreement is built between them: what data, in what format, how often, and what happens on errors. The downside of this approach is the need for coordination: the two contractors must understand each other, and someone must be accountable for the overall result. More on that below.
Responsibility matrix: who is responsible for what
To avoid “that is not our area” disputes, it helps to record from the start who is responsible for each part of the integration. An approximate scheme looks like this.
| Part of the integration | 1C programmer | Web studio |
|---|---|---|
| Exporting products, prices and stock from 1C | Responsible | Agrees the format |
| Receiving the catalogue, prices and stock on the website | Agrees the format | Responsible |
| Creating order documents, counterparties and warehouses in 1C | Responsible | Agrees the data set |
| Cart, checkout, delivery and payment on the website | Not involved | Responsible |
| Passing order statuses to the website | Provides the status | Shows it to the customer |
| Exchange schedule and error log in 1C | Responsible | Not involved |
| Retries, load handling and error notifications on the website | Not involved | Responsible |
| Exchange format between the systems | Jointly | Jointly |
| Checking the exchange after 1C or website updates | Own side | Own side |
The table is a starting point: for your project the split may be different. What matters is that a specific person is responsible for each row and that this is written into the contract or the technical specification. We wrote about how to prepare a specification in a separate article.
What to decide before work begins
Many integration problems are planted before the first line of code, when a few questions go unanswered. Which platform version and which 1C configuration you have, and how heavily it is customised for your business. What needs to go to the website: the whole catalogue or part of it, which prices (retail, wholesale, for different customer groups), which warehouses, attributes and images. How often stock and prices must be updated: once a day, once an hour or almost in real time.
It is equally important to decide where the “truth” comes from. Usually 1C is the source of truth for stock and prices and the website shows data from it, but other schemes exist, for example when part of the product information (descriptions, photos) is maintained on the website. You need to determine in advance where and by whom each kind of data is edited, otherwise the exchange will start overwriting edits made in the other system. Also think through behaviour in non-standard situations: what happens if a product runs out between adding to the cart and placing the order, how returns and cancellations are handled, and what the website shows if 1C is unavailable.
Ask a question or leave a request
We will analyse your 1C database and website, propose a working model and fix the exchange format and the split of responsibility.
By submitting the form, you agree to the processing of personal data.
How to organise the work of two teams
If both sides take part in the project, the most important thing is a single person in charge. This may be a project manager on the studio side, a technical coordinator on the client side or an independent consultant, but someone must be responsible for the integration as a whole and keep the overall picture in mind, not just their own piece. Without such a person, the contractors will solve problems on their own side and not notice what falls apart at the junction.
A practical order of work is as follows. First, both teams agree on the exchange format together with the client: what data, fields and statuses, how they are named and in what form they are passed. This document is essentially a contract between the two systems, and all later disputes are settled against it. Then each side does its part, and early trial exchanges on test data reveal discrepancies before the main budget is spent. Be sure to work on a copy of the 1C database and a test version of the website, not on live systems. It is best to keep communication in one shared working chat with all parties, so questions are not relayed through the client and distorted along the way.
Testing: the most important thing that usually gets skipped
An integration that “works on three test products” can break at every step in real life. Real data is always dirtier than test data: products without article numbers, duplicates in reference books, unusual characters in names, hundreds of thousands of items, customers without phone numbers, orders with unusual combinations of delivery and payment. That is why you need to test on a copy of live data and on real scenarios.
Check the whole cycle: loading the catalogue, changing a price and stock level in 1C and seeing it appear on the website, placing an order with different payment and delivery methods, creating the order in 1C with the right counterparty, warehouse and price, changing a status and seeing it on the website, cancellation and return. Check non-standard situations separately: one of the systems being unavailable, a duplicated order, an exchange interrupted midway, the same product being changed in two places at once. If you are preparing for a peak season such as a sale, be sure to test the load as well. Acceptance must involve the people who work with this data in practice, that is managers and the accountant, not only developers.
What breaks the integration after launch
Launch is not the end of the story. The exchange between two live systems can break after changes in either of them. The most typical causes:
- an update of the standard 1C configuration or platform that changes data structures or exchange behaviour;
- customisations in 1C that add required fields or new reference books;
- an update of the website or the e-commerce platform, or a change of the programming language version on the server;
- an expired password or access key;
- changes in the price or warehouse scheme that nobody told the developers about.
To keep these from turning into surprises, a few rules are needed: before any update of 1C or the website, check the exchange on a test copy; notify both sides about changes that affect the exchange; set up monitoring that signals when the exchange stops or errors grow; regularly reconcile data between the systems, for example the number of orders on the website and in 1C per day. We discussed the same principles in the article on lost leads: a silent failure of the exchange is the most dangerous, because nobody notices it until losses accumulate.
How to estimate cost and timeline
The cost of an integration depends not on the word “1C” itself but on several factors. The first is how heavily the configuration is customised: a standard database gives more predictable work, a non-standard one requires study and modification. The second is the volume and complexity of the data: a catalogue of hundreds of products with a single price and a catalogue of tens of thousands of items with attributes, several warehouses and price types are very different tasks in terms of effort.
The third factor is the direction and frequency of the exchange: loading the catalogue once a day is simpler than a two-way exchange of stock, prices and statuses almost in real time. The fourth is ready-made solutions: if a proven module exists for your website platform and 1C version, the cost is usually lower than writing the exchange from scratch, but setup and adaptation to your rules are still needed. Finally, the price is affected by who the contractors are: one team with competence in both areas, two teams with a coordinator, or an expert consultation at specific stages. An exact price and timeline can only be given after analysing your database and requirements. We covered the general principles of estimating development cost in the article on website and app prices.
Common mistakes
The most common mistake is not defining who is responsible for the junction. Each side is responsible for its own piece, and nobody is responsible for what happens between them, which is exactly where data usually gets lost. The second is starting implementation without agreeing the exchange format and without answering the questions about what counts as the source of data.
Integrations are often tested only on a few test products, while real dirty data is checked on the live website. The exchange is often set up on the live 1C database without a copy, which puts accounting data at risk. People forget that the exchange needs maintenance after launch and do not plan checks for updates. Another mistake is choosing a contractor only by price, without checking their experience specifically with 1C and specifically with your website platform, and hoping that a generalist will handle everything.
Checklist
- The 1C platform version and the configuration in use are known, and the degree of customisation is understood.
- It is defined which data goes to the website (products, prices, stock, warehouses, attributes) and in what volume.
- It is decided which system is the source of data for each type of information.
- The exchange method is chosen: standard format, programming interfaces or files on a schedule.
- The required update frequency for stock and prices is defined.
- The model is chosen: web studio only, 1C programmer only or both sides.
- There is a single person responsible for the integration as a whole.
- A responsibility matrix has been drawn up and agreed, and it is recorded in the contract or specification.
- The document describing the exchange format between the systems is agreed.
- Work is done on a copy of the 1C database and a test version of the website.
- Testing has been done on real data, including non-standard situations.
- Exchange monitoring and regular data reconciliation between the systems are set up.
- The procedure for checking the exchange before 1C and website updates is defined.