Tajo 사전 이용 신청

이름과 이메일 주소 또는 전화번호를 입력해 주세요. Tajo 이용 방법을 안내해 드립니다.

이 페이지에서

Shopify 연동 가이드

이 종합 가이드는 Tajo를 Shopify 스토어와 연동해 강력한 고객 참여, 로열티 프로그램, 마케팅 자동화 기능을 활용하는 과정을 단계별로 안내합니다.

개요

Tajo와 Shopify 연동으로 다음을 수행할 수 있습니다.

  • 고객 데이터 동기화: Shopify 스토어에서 자동으로 가져옵니다
  • 주문 및 상품 추적: 개인화된 마케팅에 활용합니다
  • 로열티 프로그램 운영: 포인트, 등급, 리워드를 관리합니다
  • 마케팅 캠페인 자동화: Brevo를 통해 이메일·SMS·WhatsApp으로 발송합니다
  • 고객 세그먼트 구성: 구매 행동과 참여도를 기준으로 나눕니다
  • 장바구니 이탈 회복: 자동 시퀀스로 다시 불러옵니다

사전 준비 사항

연동을 시작하기 전에 다음 항목을 준비하세요.

  • Shopify 스토어: 모든 요금제 가능(Basic, Shopify, Advanced, Plus)
  • Tajo 계정: 활성 구독 상태
  • Brevo 계정: 선택 사항이며 마케팅 자동화에 필요합니다
  • 관리자 권한: Shopify 스토어에 대한 관리자 접근 권한

1단계: Tajo 앱 설치

Shopify App Store에서 설치

  1. Shopify App Store로 이동합니다
  2. “Tajo”를 검색합니다
  3. Add app을 클릭합니다
  4. 권한을 확인한 뒤 Install app을 클릭합니다
  5. Tajo 설정 마법사로 이동합니다

수동 설치

수동으로 설정하려면 다음과 같이 진행합니다.

Terminal window
# Clone the Tajo Shopify app
git clone https://github.com/tajo/shopify-app.git


# Install dependencies
cd shopify-app
npm install


# Configure environment
cp .env.example .env

.env 파일을 다음과 같이 구성합니다.

SHOPIFY_API_KEY=your_api_key
SHOPIFY_API_SECRET=your_api_secret
SHOPIFY_SCOPES=read_customers,write_customers,read_orders,read_products
TAJO_API_KEY=your_tajo_api_key
BREVO_API_KEY=your_brevo_api_key

2단계: 데이터 동기화 구성

고객 동기화 설정

Tajo 대시보드에서 동기화할 고객 데이터를 구성합니다.

{
  "sync_settings": {
    "customers": {
      "enabled": true,
      "sync_frequency": "real-time",
      "fields": [
        "email",
        "first_name",
        "last_name",
        "phone",
        "accepts_marketing",
        "tags",
        "total_spent",
        "orders_count",
        "created_at",
        "addresses"
      ]
    },
    "orders": {
      "enabled": true,
      "sync_frequency": "real-time",
      "include_line_items": true,
      "include_fulfillments": true
    },
    "products": {
      "enabled": true,
      "sync_frequency": "hourly",
      "include_variants": true,
      "include_images": true
    }
  }
}

웹훅 구성

Tajo는 다음 Shopify 웹훅을 자동으로 등록합니다.

웹훅용도
customers/create신규 고객을 Tajo와 Brevo로 동기화합니다
customers/update고객 프로필을 최신 상태로 유지합니다
orders/create구매를 추적하고 로열티 포인트를 적립합니다
orders/paid구매 후 캠페인을 트리거합니다
orders/fulfilled배송 알림을 발송합니다
carts/create장바구니 이탈 데이터를 추적합니다
carts/update장바구니 이탈 시퀀스를 갱신합니다
products/update상품 카탈로그를 동기화 상태로 유지합니다

초기 데이터 가져오기

이미 운영 중인 스토어라면 과거 데이터를 가져옵니다.

// Import existing customers
async function importShopifyCustomers() {
  const shopify = new Shopify({
    shopName: process.env.SHOP_NAME,
    apiKey: process.env.SHOPIFY_API_KEY,
    password: process.env.SHOPIFY_PASSWORD
  });


  let customers = [];
  let params = { limit: 250 };


  do {
    const batch = await shopify.customer.list(params);
    customers = customers.concat(batch);
    params = batch.nextPageParameters;
  } while (params);


  // Sync to Tajo
  for (const customer of customers) {
    await tajo.customers.upsert({
      email: customer.email,
      firstName: customer.first_name,
      lastName: customer.last_name,
      phone: customer.phone,
      totalSpent: customer.total_spent,
      ordersCount: customer.orders_count,
      tags: customer.tags,
      source: 'shopify',
      externalId: customer.id
    });
  }


  console.log(`Imported ${customers.length} customers`);
}

3단계: 로열티 프로그램 설정

포인트 체계 구성

고객이 포인트를 적립하는 방식을 정의합니다.

const pointsConfig = {
  // Points per dollar spent
  purchasePoints: {
    enabled: true,
    rate: 1, // 1 point per $1
    roundingMode: 'floor'
  },


  // Bonus actions
  bonusPoints: {
    accountCreation: 100,
    firstPurchase: 200,
    reviewSubmitted: 50,
    referralMade: 500,
    birthdayBonus: 100,
    socialShare: 25
  },


  // Tier multipliers
  tierMultipliers: {
    Bronze: 1.0,
    Silver: 1.25,
    Gold: 1.5,
    Platinum: 2.0
  }
};

로열티 등급 정의 

const loyaltyTiers = [
  {
    name: 'Bronze',
    minPoints: 0,
    benefits: [
      '1 point per $1 spent',
      'Birthday bonus points',
      'Member-only promotions'
    ]
  },
  {
    name: 'Silver',
    minPoints: 1000,
    benefits: [
      '1.25x points multiplier',
      'Free shipping on orders $50+',
      'Early access to sales'
    ]
  },
  {
    name: 'Gold',
    minPoints: 5000,
    benefits: [
      '1.5x points multiplier',
      'Free shipping on all orders',
      'Exclusive product access',
      'Priority customer support'
    ]
  },
  {
    name: 'Platinum',
    minPoints: 15000,
    benefits: [
      '2x points multiplier',
      'Free express shipping',
      'VIP experiences',
      'Personal shopping assistant',
      'Annual gift'
    ]
  }
];

리워드 카탈로그 생성 

const rewards = [
  {
    id: 'discount_5',
    name: '$5 Off',
    pointsCost: 500,
    type: 'fixed_discount',
    value: 5,
    minPurchase: 25
  },
  {
    id: 'discount_10',
    name: '$10 Off',
    pointsCost: 900,
    type: 'fixed_discount',
    value: 10,
    minPurchase: 50
  },
  {
    id: 'percent_10',
    name: '10% Off',
    pointsCost: 750,
    type: 'percentage_discount',
    value: 10,
    maxDiscount: 50
  },
  {
    id: 'free_shipping',
    name: 'Free Shipping',
    pointsCost: 300,
    type: 'free_shipping'
  },
  {
    id: 'free_product',
    name: 'Free Gift',
    pointsCost: 2000,
    type: 'free_product',
    productId: 'gid://shopify/Product/123456'
  }
];

4단계: 장바구니 이탈 회복

장바구니 추적 구성 

// Track cart updates
shopify.webhooks.on('carts/update', async (cart) => {
  if (cart.line_items.length === 0) return;


  const customer = await getCustomerByCart(cart);
  if (!customer?.email) return;


  await tajo.carts.track({
    customerId: customer.id,
    cartToken: cart.token,
    items: cart.line_items.map(item => ({
      productId: item.product_id,
      variantId: item.variant_id,
      title: item.title,
      quantity: item.quantity,
      price: item.price,
      image: item.image
    })),
    totalPrice: cart.total_price,
    currency: cart.currency,
    checkoutUrl: cart.checkout_url
  });
});

회복 시퀀스 설정 

{
  "abandoned_cart_sequence": {
    "trigger": {
      "event": "cart_abandoned",
      "delay": "1 hour"
    },
    "emails": [
      {
        "delay": "1 hour",
        "channel": "email",
        "template": "cart_reminder_1",
        "subject": "You left something behind!"
      },
      {
        "delay": "24 hours",
        "channel": "email",
        "template": "cart_reminder_2",
        "subject": "Your cart is waiting - 10% off inside"
      },
      {
        "delay": "72 hours",
        "channel": "sms",
        "template": "cart_sms_final",
        "message": "Last chance! Your cart expires soon. Complete your order: {{checkout_url}}"
      }
    ],
    "exit_conditions": [
      "order_completed",
      "cart_emptied",
      "unsubscribed"
    ]
  }
}

5단계: Brevo를 활용한 마케팅 자동화

고객 세그먼트

Shopify 데이터를 기반으로 강력한 세그먼트를 만듭니다.

const shopifySegments = [
  // Purchase behavior
  {
    name: 'First-Time Buyers',
    conditions: { orders_count: 1 }
  },
  {
    name: 'Repeat Customers',
    conditions: { orders_count: { $gte: 2 } }
  },
  {
    name: 'VIP Customers',
    conditions: { total_spent: { $gte: 500 } }
  },
  {
    name: 'At-Risk Customers',
    conditions: {
      last_order_date: { $lt: '90 days ago' },
      orders_count: { $gte: 2 }
    }
  },


  // Product interest
  {
    name: 'Category: Electronics',
    conditions: { purchased_categories: { $contains: 'Electronics' } }
  },


  // Engagement
  {
    name: 'Abandoned Cart',
    conditions: { has_abandoned_cart: true }
  },
  {
    name: 'Browse Abandoners',
    conditions: {
      viewed_products: { $gte: 3 },
      orders_count: 0
    }
  }
];

캠페인 자동 트리거 

// Order confirmation + upsell
shopify.webhooks.on('orders/paid', async (order) => {
  const customer = await tajo.customers.get(order.customer.id);


  // Update customer stats
  await tajo.customers.update(customer.id, {
    totalSpent: customer.totalSpent + order.total_price,
    ordersCount: customer.ordersCount + 1,
    lastOrderDate: order.created_at
  });


  // Award loyalty points
  const pointsEarned = calculatePoints(order, customer);
  await tajo.loyalty.awardPoints(customer.id, pointsEarned, {
    reason: 'purchase',
    orderId: order.id
  });


  // Send to Brevo for campaigns
  await brevo.trackEvent(customer.email, 'order_completed', {
    order_id: order.id,
    order_total: order.total_price,
    points_earned: pointsEarned,
    loyalty_tier: customer.loyaltyTier,
    products: order.line_items.map(i => i.title).join(', ')
  });
});


// Post-purchase review request
const reviewRequestCampaign = {
  trigger: 'order_delivered',
  delay: '7 days',
  template: 'review_request',
  conditions: {
    customer_tags: { $not: { $contains: 'no-review-request' } }
  }
};


// Win-back campaign
const winBackCampaign = {
  trigger: 'customer_inactive',
  conditions: {
    last_order_date: '90 days ago',
    orders_count: { $gte: 1 }
  },
  sequence: [
    { delay: '0', template: 'we_miss_you', offer: '15% off' },
    { delay: '7 days', template: 'win_back_2', offer: '20% off' },
    { delay: '14 days', template: 'final_offer', offer: '25% off' }
  ]
};

6단계: 상품 추천

추천 엔진 구성 

const recommendationConfig = {
  algorithms: [
    {
      name: 'frequently_bought_together',
      weight: 0.3
    },
    {
      name: 'similar_products',
      weight: 0.25
    },
    {
      name: 'customer_also_viewed',
      weight: 0.2
    },
    {
      name: 'trending_in_category',
      weight: 0.15
    },
    {
      name: 'personalized_for_you',
      weight: 0.1
    }
  ],
  filters: {
    exclude_purchased: true,
    exclude_out_of_stock: true,
    min_rating: 3.5
  }
};


// Get recommendations for email
async function getEmailRecommendations(customerId, limit = 4) {
  const customer = await tajo.customers.get(customerId);
  const recentOrders = await tajo.orders.list({
    customerId,
    limit: 5
  });


  return await tajo.recommendations.get({
    customerId,
    purchaseHistory: recentOrders,
    browsingHistory: customer.recentlyViewed,
    limit,
    algorithms: recommendationConfig.algorithms
  });
}

7단계: 애널리틱스 및 리포팅

핵심 지표 대시보드 

const dashboardMetrics = {
  // Customer metrics
  customers: {
    total: await tajo.analytics.count('customers'),
    new_this_month: await tajo.analytics.count('customers', {
      created_at: { $gte: 'this_month' }
    }),
    returning_rate: await tajo.analytics.returningCustomerRate()
  },


  // Revenue metrics
  revenue: {
    total: await tajo.analytics.sum('orders.total'),
    average_order_value: await tajo.analytics.avg('orders.total'),
    revenue_per_customer: await tajo.analytics.revenuePerCustomer()
  },


  // Loyalty metrics
  loyalty: {
    active_members: await tajo.analytics.count('loyalty_members', {
      status: 'active'
    }),
    points_issued: await tajo.analytics.sum('points.awarded'),
    points_redeemed: await tajo.analytics.sum('points.redeemed'),
    redemption_rate: await tajo.analytics.pointsRedemptionRate()
  },


  // Campaign metrics
  campaigns: {
    emails_sent: await brevo.analytics.emailsSent('this_month'),
    open_rate: await brevo.analytics.openRate('this_month'),
    click_rate: await brevo.analytics.clickRate('this_month'),
    revenue_attributed: await tajo.analytics.campaignRevenue('this_month')
  }
};

문제 해결

자주 발생하는 문제

웹훅 전달 실패 

// Verify webhook signature
function verifyShopifyWebhook(req) {
  const hmac = req.headers['x-shopify-hmac-sha256'];
  const body = req.rawBody;
  const hash = crypto
    .createHmac('sha256', process.env.SHOPIFY_WEBHOOK_SECRET)
    .update(body)
    .digest('base64');


  return crypto.timingSafeEqual(
    Buffer.from(hash),
    Buffer.from(hmac)
  );
}

동기화 충돌 

// Handle duplicate customers
async function resolveCustomerConflict(shopifyCustomer, tajoCustomer) {
  // Merge data, preferring most recent updates
  const merged = {
    ...tajoCustomer,
    email: shopifyCustomer.email,
    firstName: shopifyCustomer.first_name || tajoCustomer.firstName,
    lastName: shopifyCustomer.last_name || tajoCustomer.lastName,
    phone: shopifyCustomer.phone || tajoCustomer.phone,
    // Keep Tajo loyalty data
    loyaltyPoints: tajoCustomer.loyaltyPoints,
    loyaltyTier: tajoCustomer.loyaltyTier
  };


  return await tajo.customers.update(tajoCustomer.id, merged);
}

레이트 리밋 

// Implement exponential backoff
async function shopifyApiCall(fn, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 429 && i < retries - 1) {
        const delay = Math.pow(2, i) * 1000;
        await new Promise(r => setTimeout(r, delay));
        continue;
      }
      throw error;
    }
  }
}

다음 단계

  1. 이메일과 SMS 캠페인을 위해 Brevo 연동 구성하기
  2. 실시간 이벤트를 위해 웹훅 설정하기
  3. 타깃 마케팅을 위해 고객 세그먼트 만들기
  4. 자동 캠페인을 위해 이메일 템플릿 제작하기

지원

Tajo 사전 이용 신청

이름과 이메일 주소 또는 전화번호를 입력해 주세요. Tajo 이용 방법을 안내해 드립니다.

자동 감지
AI 어시스턴트

안녕하세요! 문서에 대해 무엇이든 물어보세요.