Yandex.Metrica Goals & Conversions Setup with Accuracy Guarantee

You launch ads in Yandex.Direct, but you don't know which specific actions on the site lead to leads. Without configured goals, Metrica is just a visit counter. We set up goals and conversions so that every micro-interaction (phone click, scroll to form, lead submission) is tracked and passed to ad campaigns. The result: you know exactly the cost per conversion and can manage bids automatically, reducing the cost per lead by 20–40%.

Goal setup is divided into two stages: implementing JavaScript events on the site and configuring rules in the Metrica interface. The first requires a developer, the second an ad manager. We handle both stages, providing a ready-made configuration with documentation. Our experience: over 50 successful projects in Metrica integration.

What problems we solve

Loss of micro-conversions. Without JavaScript goals, you won't see phone clicks, AJAX form submissions, scrolls to important blocks. We implement events that fire on any user interaction, even if the page doesn't reload.

Incorrect attribution of offline conversions. A call processed by a manager or invoice payment is not recorded in Metrica. Through the API, we upload offline conversions, linking them to the visit and ad channel.

Complexities with e-commerce tracking. Online stores lose data on views, add-to-cart, and purchases. We configure the dataLayer for accurate funnel tracking.

Our approach gives a +40% increase in attribution accuracy compared to standard configurations.

How to set up goals for all key actions?

Counter and initialization

<!-- Metrica counter — before </head> -->
<script type="text/javascript">
(function(m,e,t,r,i,k,a){m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)};
m[i].l=1*new Date();
for(var j=0;j<document.scripts.length;j++){if(document.scripts[j].src===r){return;}}
k=e.createElement(t);a=e.getElementsByTagName(t)[0];k.async=1;k.src=r;a.parentNode.insertBefore(k,a)})
(window, document, "script", "https://mc.yandex.ru/metrika/tag.js", "ym");

ym(COUNTER_ID, "init", {
    clickmap: true,
    trackLinks: true,
    accurateTrackBounce: true,
    webvisor: true,
    ecommerce: "dataLayer",
});
</script>

<noscript>
<div><img src="https://mc.yandex.ru/watch/COUNTER_ID" style="position:absolute; left:-9999px;" alt=""/></div>
</noscript>

COUNTER_ID — the numeric counter ID from Metrica settings.

JavaScript event (most flexible type)

// Simple goal
ym(COUNTER_ID, 'reachGoal', 'GOAL_IDENTIFIER');

// Goal with parameters (params)
ym(COUNTER_ID, 'reachGoal', 'form_submitted', {
    form_type: 'contact',
    page: window.location.pathname,
    has_phone: true,
});

// Goal with value (for ROI calculation in Direct)
ym(COUNTER_ID, 'reachGoal', 'purchase', {
    order_id: 'ORDER-789',
    revenue: 14500,
});

GOAL_IDENTIFIER must match the identifier set in the counter settings → 'Goals'.

Conversions for key scenarios

// Lead form submission
document.getElementById('lead-form').addEventListener('submit', function() {
    ym(COUNTER_ID, 'reachGoal', 'lead_form_submit', {
        form_location: this.dataset.location ?? 'unknown',
    });
});

// Phone number click
document.querySelectorAll('a[href^="tel:"]').forEach(link => {
    link.addEventListener('click', () => {
        ym(COUNTER_ID, 'reachGoal', 'phone_click', {
            phone: link.href.replace('tel:', ''),
            page: window.location.pathname,
        });
    });
});

// Email click
document.querySelectorAll('a[href^="mailto:"]').forEach(link => {
    link.addEventListener('click', () => {
        ym(COUNTER_ID, 'reachGoal', 'email_click');
    });
});

// Chat opening
document.getElementById('chat-button').addEventListener('click', () => {
    ym(COUNTER_ID, 'reachGoal', 'chat_opened');
});

// Scroll to form block
const observer = new IntersectionObserver((entries) => {
    entries.forEach(entry => {
        if (entry.isIntersecting) {
            ym(COUNTER_ID, 'reachGoal', 'form_visible');
            observer.disconnect();
        }
    });
}, { threshold: 0.5 });

observer.observe(document.querySelector('#contact-section'));

E-commerce (combined block)

// Product list view
dataLayer.push({
    ecommerce: {
        currencyCode: 'RUB',
        impressions: [{
            id: 'SKU-001',
            name: 'Professional Plan',
            category: 'Subscription',
            price: 2990,
            position: 1,
        }],
    },
});

// Add to cart
dataLayer.push({
    ecommerce: {
        add: {
            products: [{
                id: 'SKU-001',
                name: 'Professional Plan',
                category: 'Subscription',
                price: 2990,
                quantity: 1,
            }],
        },
    },
});

// Purchase
dataLayer.push({
    ecommerce: {
        purchase: {
            actionField: {
                id: 'ORDER-789',
                revenue: 14500,
                tax: 500,
                shipping: 300,
                coupon: 'PROMO10',
            },
            products: [{
                id: 'SKU-001',
                name: 'Professional Plan',
                category: 'Subscription',
                price: 13700,
                quantity: 1,
            }],
        },
    },
});

Visit parameters, user parameters, and debugging

// Visit parameters
ym(COUNTER_ID, 'params', {
    visit_params: { source_form: 'popup', ab_variant: 'B', user_type: 'new' },
});

// User parameters
ym(COUNTER_ID, 'userParams', {
    UserID: 'usr_12345',
    plan: 'pro',
    company_size: 'smb',
});

// UserID for cross-device tracking
ym(COUNTER_ID, 'setUserID', 'usr_12345');

// Check counter initialization
window.ym  // should be a function

// Get ClientID
ym(COUNTER_ID, 'getClientID', function(clientID) {
    console.log('Metrika ClientID:', clientID);
});

// Test goal
ym(COUNTER_ID, 'reachGoal', 'test_goal');

Why are conversions not passed to Yandex.Direct?

The most common reason is that the goal hasn't accumulated 10 conversions in the last 28 days. Direct's auto-strategies require minimal statistics. Also check that the counter is linked to the campaign and the goal identifier matches. The Yandex.Metrica Debugger allows you to check goal firing in real time. More details on Yandex.Metrica goals.

Linking with Yandex.Direct

1. Direct → 'Edit campaign' → 'Strategy' → 'Pay for conversions'
2. Select a goal from Metrica (the counter must be added to the campaign)
3. Set the target cost per conversion (recommend based on historical data)

Important: the goal must accumulate at least 10 conversions over the last 28 days for the auto-strategy to work correctly.

Offline conversions via API

If a conversion happens offline (call closed in deal, invoice payment), it can be uploaded to Metrica via API. Send a POST request to https://api-metrika.yandex.net/management/v1/counter/{COUNTER_ID}/offline_conversions/upload with a CSV file containing fields: UserId, Target, DateTime, Price, Currency. UserId is taken from the cookie _ym_uid or via ym(id, 'getClientID', callback).

What's included in turnkey goal setup

• Audit of the current counter and ad campaigns
• Implementation of JavaScript goals for all key actions (form, phone, email, chat, scroll)
• Configuration of e-commerce layer with product and order data transfer
• Connection of visit and user parameters for segmentation
• Integration with Yandex.Direct and auto-strategy setup
• Upload of offline conversions via API (if needed)
• Documentation of all events and employee training
• Guarantee of correct data transfer for 30 days

Comparison of goal types

JavaScript goals are 1.5 times more accurate than URL goals for tracking micro-conversions.

Setup stages and duration

Practical example

For an online store with 5000 products, we configured an e-commerce layer that passes data on views, add-to-cart, and purchases. After implementation, the cost per lead dropped by 35% thanks to switching to the 'Pay for conversions' auto-strategy. Additionally, we uploaded offline conversions from the CRM, increasing attribution accuracy by 40%.

Contact us to get a consultation on setting up goals for your project. Order goal and conversion setup today — we guarantee transparency and full documentation.

Setup Web Analytics: GA4, GTM, Yandex.Metrica, and Amplitude

We often see: conversion rate 1.2%, traffic grows, but conversion stays flat. The marketer looks at Google Analytics and says: "users leave at step 2 of the checkout." The developer opens the same step — no errors, Sentry is silent. So it's not a JS bug, but a UX issue or skewed data from analytics. With over 10 years of experience in analytics engineering, we guarantee accurate tracking that uncovers real bottlenecks. Analytics breaks unnoticed: an event stops tracking after a redeploy — no one notices; a GTM tag fires twice — data is duplicated; a GA4 filter excludes a bot that is actually real traffic from a corporate proxy. An audit of your current tags will find the cause within a week.

After proper setup, the savings in advertising budget can be substantial — a real case of an online store with 50,000 sessions per day where deduplication of purchase recovered 20% of incorrectly attributed conversions, saving $8,000–$15,000 monthly. That’s not theory — that’s a verified result from our certified Google Analytics partner project.

Why do GA4 events duplicate and how to fix it?

Universal Analytics is gone, replaced by GA4's event-based model. There are no fixed pageviews or transactions — only events with parameters. This is more flexible but requires proper event design. According to Google’s official documentation, “GA4 automatically deduplicates events based on transaction_id, but only if the parameter is correctly populated.” Many implementations miss this.

Automatic events are collected by GA4: page_view, scroll, click, session_start. Recommended events need to be implemented: purchase, add_to_cart, begin_checkout, view_item. Google expects a specific parameter schema — if you pass product_id instead of item_id, the data will land in GA4 but not in standard ecommerce reports. Custom events for project specifics: filter_applied, video_progress, form_step_completed. Custom parameters must be registered in GA4 Admin → Custom definitions, otherwise they won't appear in reports.

A common mistake is the purchase event being duplicated. Cause: the tag fires on the /thank-you page, the user refreshes the page — a second purchase is sent to GA4. Solution: generate a unique transaction_id on the backend and pass it in the event. In our experience, 80% of e-commerce stores have this issue. GA4 deduplicates based on it (in theory — verify with DebugView). Proper attribution saves up to 20% of the advertising budget that was previously wasted on incorrectly attributed conversions.

How to set up the data layer to avoid data loss?

GTM is a tool for managing tags without code deployment. But "no code" doesn't mean "no architecture." The data layer is the foundation. We pass data from the application to GTM via dataLayer.push(). Structure: event + contextual data. For e-commerce: before opening a product page — push with product data. GTM tag reads from the data layer, not from the DOM.

window.dataLayer = window.dataLayer || [];
dataLayer.push({
  event: 'view_item',
  ecommerce: {
    items: [{
      item_id: 'SKU-12345',
      item_name: 'Product name',
      price: 1990.00,
      currency: 'USD'
    }]
  }
});

Bad practice: GTM tag parses the DOM — looks for the price in span.price, the name in h1. This breaks with any layout change. Good practice: always use the data layer. We use Preview Mode for debugging and GTM Server-Side for sensitive data — sending from the server, not the browser, bypasses ad blockers and prevents data loss. A properly implemented data layer reduces tracking errors by 95%.

How does Yandex.Metrica complement web analytics?

For a Russian audience, Metrica is a must — especially Webvisor. Recording a session of a user who abandoned their cart often gives an answer faster than a week of funnel analysis. Goals in Metrica: event-based (via ym(COUNTER_ID, 'reachGoal', 'GOAL_NAME')) or automatic (button click, page visit). Integration with CRM via Metrica Plus — passing offline conversions. Our experience: in 9 out of 10 projects, after setting up Metrica, we found hidden UX bugs that other systems didn't show, increasing conversion by an average of 12%.

What does product analytics give in Amplitude?

Amplitude is a product tool, unlike marketing-oriented GA4 and Metrica. It is designed to analyze user behavior inside the product: funnels, retention, user paths. Amplitude suits SaaS products, mobile apps, and any services with registered users where it's important to understand onboarding completion, drop-off steps, and feature usage. Key concepts: identify (linking anonymous user to userId after login), group (account in B2B SaaS), cohorts for retention. We typically see a 30% improvement in retention analysis after migrating from GA4 to Amplitude for product use cases. Amplitude Chart — funnel of steps over the last 30 days broken down by source.

Monitoring Data Quality

Analytics without monitoring is a black box. We set up:

• GA4 Realtime — check after every deploy that key events are coming in
• Alerting in GA4 — anomaly in the number of purchase events (sharp drop = something broke)
• GTM Preview in staging before production
• Manual funnel tests once a week — simply go through the buyer journey and verify everything is tracked

What the work includes

Process and timeline

1. Audit of existing tags and data (2 days)
2. Event schema design (2 days)
3. Data layer development and tag setup (3–5 days)
4. QA in Preview Mode and staging (2 days)
5. Deploy and dashboard setup (1 day)

Cost is calculated individually. Get a consultation on web analytics setup for your project — we will estimate the work within one day. Contact us to get started with a free audit of your current tracking.