Hoppa till huvudinnehåll

​
Introduktion

DataFast är ett intäktsfokuserat analysverktyg som hjälper dig att upptäcka vilka marknadsföringskanaler som driver betalande kunder. Genom att integrera Dodo Payments med DataFast kan du attributera intäkter till dina trafik källor, identifiera högvärdiga kundsegment och fatta datadrivna beslut för att växa ditt företag.
Den här integrationen kräver din DataFast API-nyckel, som du kan skaffa från din DataFast-instrumentpanel.

​
Hur Det Fungerar

DataFast spårar besökare genom ett unikt besökar-ID som lagras i en cookie. För att attributera intäkter till marknadsföringskanaler behöver du:
  1. Fånga DataFast:s besökar-ID från datafast_visitor_id-kakan när du skapar checkout-sessioner
  2. Lagra besökar-ID:t i din betalningsmetadata
  3. Skicka betalningsdata till DataFast när betalningar lyckas via deras Payment API
Detta gör att DataFast kan matcha lyckade betalningar med den ursprungliga trafik källan, vilket ger dig fullständig intäktsattribution.

​
Komma Igång

1

Install DataFast Script

Börja med att installera DataFast-spårningsskriptet på din webbplats. Detta skapar datafast_visitor_id-kakan som spårar dina besökare.Besök DataFast-dokumentationen för installationsinstruktioner specifika för din plattform.
2

Get Your API Key

Logga in på din DataFast-instrumentpanel och gå till webbplatsinställningarna för att hämta din API-nyckel.
Håll din API-nyckel säker och exponera den aldrig i klientkod.
3

Capture Visitor ID in Checkout

När du skapar en checkout-session, fånga DataFast-besökar-ID:t från kakan och lägg till det i din betalningsmetadata.
4

Send Payment Data via Webhook

Konfigurera en webhook för att skicka betalningsdata till DataFast:s Payment API när betalningar lyckas.
5

Done!

🎉 Intäktsdata kommer nu att visas i din DataFast-instrumentpanel med full attribuering till marknadsföringskanaler.

​
Implementeringsguide

​
Steg 1: Lägg till Besökar-ID i Kassa Metadata

När du skapar en kassa session, fånga DataFast besökar-ID från cookien och inkludera det i din betalningsmetadata. 
import { cookies } from 'next/headers';
import { dodopayments } from '@/lib/dodopayments';

export async function createCheckout(productId: string) {
  // Capture DataFast visitor ID from cookie
  const datafastVisitorId = cookies().get('datafast_visitor_id')?.value;

  const payment = await dodopayments.payments.create({
    product_id: productId,
    // ... other payment configuration
    metadata: {
      datafast_visitor_id: datafastVisitorId, // Store visitor ID in metadata
    },
  });

  return payment;
}

​
Steg 2: Skicka Betalningsdata till DataFast

Konfigurera en webhook-endpoint för att skicka betalningsdata till DataFast’s Betalnings-API när betalningar lyckas.
1

Open the Webhook Section

I din Dodo Payments-instrumentpanel, navigera till Webhooks → + Add Endpoint och expandera rullgardinsmenyn för integrationer.
Lägg till slutpunkt och rullgardinsmenyn för integrationer
2

Select DataFast

Välj DataFast-integrationskortet.
3

Enter API Key

Ange din DataFast API-nyckel i konfigurationsfältet.
Lägg till API-nyckel
4

Configure Transformation

Redigera transformationskoden för att formatera betalningsdata för DataFast:s Payment API.
5

Test & Create

Testa med exempelpayloader och klicka på Create för att aktivera integrationen.

​
Transformationskodsexempel

​
Grundläggande Betalningsattribution

basic_payment.js
function handler(webhook) {
  if (webhook.eventType === "payment.succeeded") {
    const payment = webhook.payload.data;
    
    // Only send to DataFast if visitor ID exists in metadata
    if (payment.metadata && payment.metadata.datafast_visitor_id) {
      webhook.payload = {
        amount: payment.total_amount / 100, // Convert from cents to dollars
        currency: payment.currency,
        transaction_id: payment.payment_id,
        datafast_visitor_id: payment.metadata.datafast_visitor_id,
      };
    } else {
      // Cancel dispatch if no visitor ID (prevents unnecessary API calls)
      webhook.cancel = true;
    }
  }
  return webhook;
}

​
Hantera Valutor Utan Decimaler

Vissa valutor (som JPY) använder inte decimaler. Justera beloppsberäkningen därefter:
zero_decimal.js
function handler(webhook) {
  if (webhook.eventType === "payment.succeeded") {
    const payment = webhook.payload.data;
    
    if (payment.metadata && payment.metadata.datafast_visitor_id) {
      // Zero decimal currencies: JPY, KRW, CLP, etc.
      const zeroDecimalCurrencies = ['JPY', 'KRW', 'CLP', 'VND', 'UGX', 'MGA'];
      const isZeroDecimal = zeroDecimalCurrencies.includes(payment.currency);
      
      webhook.payload = {
        amount: isZeroDecimal 
          ? payment.total_amount // Use amount as-is for zero decimal currencies
          : payment.total_amount / 100, // Convert from cents for other currencies
        currency: payment.currency,
        transaction_id: payment.payment_id,
        datafast_visitor_id: payment.metadata.datafast_visitor_id,
      };
    } else {
      // Cancel dispatch if no visitor ID (prevents unnecessary API calls)
      webhook.cancel = true;
    }
  }
  return webhook;
}

​
Prenumerationsbetalningar

För återkommande prenumerationsbetalningar kan du spåra varje betalning:
subscription_payment.js
function handler(webhook) {
  if (webhook.eventType === "payment.succeeded") {
    const payment = webhook.payload.data;
    
    // Check if this is a subscription payment
    const isSubscription = payment.subscription_id !== null;
    
    if (payment.metadata && payment.metadata.datafast_visitor_id) {
      webhook.payload = {
        amount: payment.total_amount / 100,
        currency: payment.currency,
        transaction_id: payment.payment_id,
        datafast_visitor_id: payment.metadata.datafast_visitor_id,
        // Optional: Add subscription context
        ...(isSubscription && {
          subscription_id: payment.subscription_id,
        }),
      };
    } else {
      // Cancel dispatch if no visitor ID (prevents unnecessary API calls)
      webhook.cancel = true;
    }
  }
  return webhook;
}

​
Bästa Praxis

Fånga besökar-ID:t tidigt: Spara DataFast-besökar-ID:t så snart som möjligt i din checkout-flöde för att säkerställa korrekt attribuering, även om användaren lämnar och återkommer senare.
  • Inkludera alltid besökar-ID i metadata: Utan besökar-ID kan DataFast inte attributera intäkter till marknadsföringskanaler
  • Hantera valutor utan decimaler: Vissa valutor (JPY, KRW, etc.) använder inte decimaler—justera din beloppsberäkning därefter
  • Testa med exempelbetalningar: Verifiera att integrationen fungerar korrekt innan du går live
  • Övervaka din DataFast-instrumentpanel: Kontrollera att betalningar visas korrekt med rätt attribution
  • Använd webhook-retries: DataFast’s Betalnings-API är idempotent, så retries är säkra om en webhook misslyckas

​
Felsökning

  • Verifiera att din DataFast API-nyckel är korrekt och aktiv
  • Kontrollera att datafast_visitor_id fångas och lagras i betalningsmetadata
  • Se till att webhook-transformationen formaterar nyttolasten korrekt
  • Verifiera att webhooken triggas vid payment.succeeded-händelser
  • Kontrollera DataFast-instrumentpanelen efter eventuella felmeddelanden eller API-loggar
  • Bekräfta att DataFast-spårningsskriptet är installerat och fungerar på din webbplats
  • Verifiera att datafast_visitor_id-kakan sätts korrekt
  • Kontrollera att besökar-ID:n matchar mellan skapande av checkout och slutförd betalning
  • Se till att du fångar besökar-ID:t innan du skapar checkout-sessionen
  • Granska DataFast:s Payment API-dokumentation för ytterligare vägledning
  • Validera att JSON-strukturen matchar DataFast:s Payment API-format
  • Kontrollera att alla obligatoriska fält (amount, currency, transaction_id, datafast_visitor_id) finns med
  • Se till att beloppet konverteras korrekt (dividera med 100 för de flesta valutor, förutom valutor utan decimaler)
  • Verifiera att API-slutpunkts-URL:en är korrekt: https://datafa.st/api/v1/payments
  • Testa transformationen med exempelpayloader för webhooken
  • För valutor utan decimaler (JPY, KRW, CLP, VND, UGX, MGA) skicka beloppet som det är utan att dividera med 100
  • För alla andra valutor, dividera beloppet med 100 för att konvertera från cent till basenhet
  • Dubbelkolla att valutakoden matchar ISO 4217-formatet (t.ex. “USD”, “EUR”, “JPY”)

​
Ytterligare Resurser

DataFast Documentation

Läs mer om DataFast:s Payment API och funktionerna för intäktsattribuering.

DataFast Dashboard

Gå till din DataFast-instrumentpanel för att se intäktsanalys och attribueringsdata.
Behöver du hjälp? Kontakta Dodo Payments support på support@dodopayments.com för assistans med integrationen.