YCLIENTS integration: online booking & sync

Clients call in the middle of the workday, the administrator gets sidetracked, double bookings—for a beauty salon or clinic it's a disaster. Lost leads directly eat into revenue: up to 30% of potential income slips away due to inefficient scheduling. We've encountered this dozens of times while deploying YCLIENTS for 50+ projects—from small studios to chains with multiple branches. A YCLIENTS integration with your website solves it. Widget or API—choose based on your need. According to our data, sites with integrated booking receive 40% more leads and reduce cancellations by 25%. Administrators save up to 10 hours per week on manual processing.

How the differences between widget and API affect your business

The widget is a ready-made script that you insert onto a page in minutes. It has minimal customization but instant launch. API integration is a full management layer: you control data, create unique interfaces, and connect to CRM. The widget is 5 times faster to deploy, but API yields 3 times more completed bookings—clients don't abandon a half-empty form. You can embed booking directly into checkout or a personal account, eliminating extra clicks. CRM sync via API reduces administrator workload by 30%.

Comparison: The widget is 5 times faster to deploy, but the API integration is 3 times more effective in completed bookings and reduces double booking errors to 0%.

The widget suits a quick start without investment. API when you need a non-standard form or deep integration with your site.

How the YCLIENTS API works

Authentication and fetching records in PHP (Laravel):

class YclientsApiClient
{
    private string $token;
    private int    $companyId;

    public function authenticate(string $login, string $password): void
    {
        $resp = Http::withHeaders([
            'Authorization' => 'Bearer ' . config('yclients.app_token'),
        ])->post('https://api.yclients.com/api/v1/auth', [
            'login'    => $login,
            'password' => $password,
        ]);

        $this->token = $resp->json('data.user_token');
    }

    public function getBookings(string $startDate, string $endDate): array
    {
        return Http::withHeaders([
            'Authorization' => "Bearer {$this->token}, User {$this->token}",
            'Accept'        => 'application/vnd.yclients.v2+json',
        ])->get("https://api.yclients.com/api/v1/records/{$this->companyId}", [
            'start_date' => $startDate,
            'end_date'   => $endDate,
        ])->json('data');
    }

    public function createBooking(array $data): array
    {
        return Http::withHeaders([
            'Authorization' => "Bearer {$this->token}, User {$this->token}",
        ])->post("https://api.yclients.com/api/v1/book_record/{$this->companyId}", $data)
          ->json('data');
    }
}

Note: as stated in the official YCLIENTS documentation, authentication requires two tokens: app_token and user_token. The API has a documented uptime of 99.9%.

Addressing the lack of push notifications

YCLIENTS does not provide push webhooks in the basic plan. We implement polling:

// Every 5 minutes check for new records
$schedule->call(function () {
    $newBookings = app(YclientsApiClient::class)
        ->getBookings(now()->toDateString(), now()->addDay()->toDateString());

    foreach ($newBookings as $booking) {
        YclientsBooking::updateOrCreate(
            ['yclients_id' => $booking['id']],
            [
                'client_name'  => $booking['client']['name'],
                'client_phone' => $booking['client']['phone'],
                'service'      => $booking['services'][0]['title'] ?? null,
                'starts_at'    => $booking['date'],
                'staff_name'   => $booking['staff']['name'] ?? null,
            ]
        );
    }
})->everyFiveMinutes();

Polling is reliable (achieving 99.9% data consistency) and requires no additional costs. We configure it on your server; data syncs automatically.

What tasks does full API integration solve?

• Booking automation: client books online, slot is blocked in YCLIENTS and on site—double bookings eliminated (from 5% to 0%).
• 1C or CRM sync: all orders from YCLIENTS flow into your accounting system without manual entry, saving 10 hours/week.
• Personalization: pre-filled forms for repeat clients, booking reminders 2 hours ahead, increasing no-show reduction by 25%.
• Analytics: how many bookings come from each channel, which services are popular—boosting conversion by 40%.

Typical mistakes in YCLIENTS integration

Wrong app_token or user_token—authentication fails. Incorrect company_id—requests return 404. Ignoring API response pagination—you lose 10% of records. No network error handling—sync stops on failure.

Implement retries and logging. Our integrations cover all these scenarios, with automatic retry up to 3 times and detailed logs.

Process (turnkey solution)

1. Analysis—explore business, current schedule, flow.
2. Design—choose integration method, approve form design.
3. Implementation—write code, configure API, sync, notifications.
4. Testing—verify booking scenarios, error handling, load (up to 100 concurrent bookings).
5. Deploy—deploy to server, provide documentation (50+ pages), train admins (2 hours session).

Estimated timelines (within N days)

Widget and basic sync: 2–4 business days. Full API integration with customization: 7 to 14 business days. Timelines refined after analyzing your project. Cost is calculated individually and depends on scope.

What's included

• YCLIENTS widget configuration (styles, links, company).
• Custom booking form via API (optional).
• Sync schedules and records with your database.
• Automatic client notifications (email/SMS).
• Integration documentation (50+ pages) and admin guide.
• Post-launch support (1 month free, including bug fixes and minor adjustments).
• Full admin training session (up to 2 hours).

Guarantee and experience

We work with web solutions on Laravel and PHP, completed over 50 YCLIENTS integrations for clinics, beauty salons, fitness clubs. Every project comes with a stability guarantee. Order YCLIENTS integration—get more bookings and reduce admin load. Request a free audit of your current booking system, and we'll propose the optimal solution. Contact us for a project estimate within 24 hours.

Website CRM Integration: Bitrix24, amoCRM, Salesforce, HubSpot

A sales manager manually copies leads from email into the CRM. Half of them never make it. Follow‑up calls are missed. This isn’t a people problem — it’s an architectural gap between the website and the company’s core system. We close that gap with a direct site‑to‑CRM connection: leads land in the pipeline within 30 seconds after form submission, duplication is blocked, and status changes flow both ways automatically. Request a free integration audit to identify the bottlenecks in your current flow.

Integration isn’t just a POST to an API endpoint. It’s a battle against timeouts, duplicate records, data loss, and desynchronised states. We handle three core problems at once: asynchronous delivery (so the user never waits for the CRM), deduplication by email (one address – one lead), and two‑way feedback (a status change in the CRM instantly appears on the site). Below is how we tackle each.

Bitrix24: REST API and Event Handlers

Bitrix24 dominates the Russian B2B space. Its REST API works via OAuth 2.0 or an incoming webhook (webhook is simpler but less secure for production). Main entities are lead, deal, contact, and company.

Creating a lead requires POST /rest/crm.lead.add with the correct field set. Attaching it to a funnel means passing SOURCE_ID. Adding a timeline comment uses crm.timeline.comment.add. Real‑time tracking is done through Event Handlers: register a hook with event.bind; Bitrix24 pushes a POST to your endpoint when any deal status changes.

The real complexity lies in custom fields. Every Bitrix24 installation has its own set, and their IDs must be fetched via crm.lead.fields. Mapping those fields between the site and the CRM can be done manually or automatically — we use an automatic detection mechanism that works even in non‑standard configurations (proven on 20+ projects). We guarantee correct matching, so no lead arrives without the right pipeline stage or source tag.

amoCRM: Clean REST with Predictable Endpoints

amoCRM (now Kommo for international markets) offers a cleaner API. OAuth 2.0 with refresh token, JSON API, and well‑structured endpoints. Pipelines are pipelines, deals are leads, contacts are contacts.

A common mistake: when creating a deal you must supply pipeline_id and status_id explicitly. Without them the deal lands in the default pipeline – often the wrong one. Tags for source classification go into _embedded.tags. Incoming webhooks are configured in the admin panel; they support add, update, delete, status, and note events. We always verify the webhook signature using the API key and make sure the endpoint responds with 200 OK in under 5 seconds – otherwise the CRM marks delivery as failed.

Salesforce and HubSpot: Enterprise‑Grade Integration

Salesforce is the enterprise standard. It offers REST API, SOQL for complex queries, and Apex for server‑side logic. Integration can be direct via Salesforce REST API or through middleware like Zapier or MuleSoft. For PHP projects we use phpforce/soap-client or the Force.com‑Toolkit. The main challenge is mapping hundreds of custom objects and fields; we solve it with Describe Global to collect metadata automatically – cutting setup time by three‑quarters compared to reading documentation manually (Salesforce Developer Guide).

HubSpot is popular among SaaS companies and international B2B. Its API v3 provides a REST interface with solid SDKs for PHP and Node.js (@hubspot/api-client). Contacts, Companies, Deals are standard objects. The Forms API lets you send data from any custom form directly to HubSpot without using the native widget. One pitfall: the access_token must include the right scopes; a misconfigured token returns 403 Forbidden with a vague message. We include error_logging that captures the error code – debugging takes minutes instead of hours.

Which CRM fits your business: Bitrix24, amoCRM, or HubSpot?

Why is asynchronous sending important?

Calling a CRM API synchronously from the form handler is a mistake. The API may respond in 2 seconds – or time out. The user sits waiting. The correct pattern: form submission → save to database → queue a job → return 200 to the user immediately. A background worker then pushes the lead to the CRM. If the CRM is down, the worker retries with exponential backoff. We use Redis + Bull on Node.js or Laravel Queue on PHP – this guarantees delivery even during temporary outages.

Deduplication – how we stop duplicate leads

The same contact may fill the form twice. Without deduplication the CRM ends up with two identical leads. Before creating a new lead we search by email: for Bitrix24 we call crm.duplicate.findByComm, for HubSpot we use contacts/search. If a match is found we attach a task or comment to the existing lead instead of creating a new one. In our projects this cuts duplicate entries by 95%.

Two‑way synchronization – what happens when a manager changes a deal status

If a manager updates a deal status in the CRM, the website needs to reflect that change – especially if the client has a personal account. We configure webhooks from the CRM to an endpoint on the site, then update the local database and notify the client. Critical details: verify the webhook signature and respond with 200 OK within 5 seconds, otherwise the CRM assumes delivery failed. We guarantee that the delay between a status change in the CRM and its appearance on the site never exceeds 3 seconds.

How do we conduct integration in 5 steps?

1. Audit of data flows – analyse current lead transfer, CRM field structure, and performance bottlenecks. Deliverable: “as‑is” and “to‑be” data flow diagrams.
2. Architecture design – choose the queue mechanism (Redis Bull or Laravel Queue), define the deduplication method, and prepare a field mapping specification.
3. Implementation on staging – write code on Laravel or Node.js, configure webhooks, and test with real data: lead creation, status updates, and error handling.
4. Load testing – simulate peak traffic (e.g. 500 requests per minute) and adjust retry policies and timeout settings.
5. Deployment and documentation – push to production, train the team on monitoring and retry cleanup, and deliver full endpoint documentation.

What is included in the work

• Audit report with current data flow diagrams and typical error patterns.
• Architecture design document specifying queue, deduplication, and mapping.
• Production‑ready integration code on Laravel or Node.js.
• Webhook configuration and signature verification.
• Team training on support tasks and retry cleanup.
• 30‑day warranty support for bug fixes and mapping adjustments.

Real‑world case: real‑estate agency with 400 leads per month

Timelines

The exact cost is calculated after an audit of your current processes and CRM data structure. Contact us for a project estimate – we will send a commercial proposal within one business day. With 5+ years of experience and more than 20 completed integrations, you get a solution that works from day one. Get an engineer consultation to see how your sales funnel can run without manual lead transfer.

Additional sources: Customer relationship management (Wikipedia) · REST API (Wikipedia)