Jak korzystać z interfejsu Shoply Merchant API

Shoply Merchant API umożliwia sprzedawcy bezpieczne używanie własnych danych Shoply w narzędziach raportowych, procesach wsparcia, zaplanowanych eksportach oraz prywatnych aplikacjach biznesowych.

Każda integracja uwierzytelnia się za pomocą możliwego do unieważnienia poświadczenia przypisanego do sklepu, utworzonego w ustawieniach Shoply. Nie musisz udostępniać tokena dostępu Shopify Admin API, a integracja może uzyskać dostęp tylko do sklepu, który wystawił jej poświadczenie.

Co mogę zrobić za pomocą Merchant API?

Możesz używać Merchant API do:

• Eksportowania dziennych, tygodniowych lub miesięcznych wyników wydajności do arkusza kalkulacyjnego lub hurtowni danych.
• Budowania prywatnego panelu dla sesji, czatów, wyszukiwań, kliknięć produktów, zdarzeń dodania do koszyka, zakupów i przypisanego przychodu.
• Monitorowania aktywności klientów i wykrywania nietypowych zmian w zaangażowaniu.
• Przeglądania sesji czatu i wyszukiwania na potrzeby wsparcia, merchandisingu i pracy nad jakością odpowiedzi.
• Pobierania osi czasu pojedynczej rozmowy podczas badania problemu klienta.
• Tworzenia, aktualizowania, wyświetlania i usuwania niestandardowej wiedzy używanej przez Shoply AI.
• Dodawania zewnętrznej strony internetowej lub przesłanego pliku PDF, tekstowego albo Markdown do bazy wiedzy.
• Dopasowywania danych zdarzeń UTC do lokalnej strefy czasowej sklepu.

Ten przewodnik opisuje siedem endpointów. Pięć z nich to te same endpointy, których używa Shoply Admin → Analytics, a dwa służą do zarządzania bazą wiedzy:

Treści odpowiedzi poniżej to przykładowe reprezentatywne próbki. Twoje pola i wartości będą odzwierciedlać aktywność zarejestrowaną dla Twojego sklepu.

Wymaganie wdrożeniowe: Uwierzytelnianie tajnym kluczem właściciela sklepu musi być wdrożone na serwerze API, który wywołujesz. Jeśli prawidłowy sekret zwraca HTTP 403 z komunikatem No access_token found, ten serwer nadal korzysta ze starszego kodu uwierzytelniania obsługującego wyłącznie token dostępu.

Jak utworzyć tajny klucz API?

1. Otwórz panel administracyjny Shoply AI.
2. Przejdź do Settings → Store owner API secret.
3. Utwórz sekret i nadaj mu nazwę identyfikującą integrację, na przykład Weekly reporting export.
4. Skopiuj sekret, gdy się pojawi. Shoply pokazuje wartość jawną tylko raz.

Każdy sekret jest ważny przez 90 dni. Sklep może mieć osobne sekrety dla osobnych integracji, a Ty możesz unieważnić jeden sekret bez przerywania działania pozostałych.

Zapisz te wartości jako zmienne środowiskowe po stronie serwera:

export SHOPLY_STORE_KEY="your-store.myshopify.com"
export SHOPLY_STORE_OWNER_API_SECRETE="shoply_owner_key_example123.secret-value"

Użyj stałej domeny sklepu myshopify.com dla SHOPLY_STORE_KEY, nawet jeśli klienci zwykle odwiedzają domenę niestandardową.

Jak działa uwierzytelnianie?

Każde żądanie Merchant API wysyła nagłówek Authorization, którego wartość jest ciągiem JSON:

{
  "store_key": "your-store.myshopify.com",
  "store_owner_api_secrete": "YOUR_STORE_OWNER_API_SECRET"
}

store_owner_api_secrete to dokładna publiczna nazwa pola, łącznie z jej historyczną pisownią. To nie jest token Bearer. Umieść cały ciąg JSON bezpośrednio w nagłówku Authorization.

Przechowuj sekret wyłącznie w kodzie backendowym. Nie umieszczaj go w adresie URL, pakiecie przeglądarkowym, publicznym repozytorium, zdarzeniu analitycznym ani logu aplikacji.

Czy istnieją oficjalne pakiety dla Pythona i Node.js?

Tak. Shoply publikuje dwa pakiety po stronie serwera, które automatycznie dodają wymagane uwierzytelnianie i udostępniają Merchant API jako typowane funkcje. Oba pakiety są open source w organizacji GitHub shoplyai-public.

Pakiet Python

Pakiet shoply-merchant-api obsługuje Python 3.12 i używa modeli odpowiedzi Pydantic v2. Zainstaluj przypięte wydanie 2.1.3:

python3.12 -m venv .venv
source .venv/bin/activate
python -m pip install "git+https://github.com/shoplyai-public/shoply-merchant-api.git@v2.1.3"

Pobierz najnowsze sesje czatu i wyszukiwania jako typowane modele SessionSummary:

import os
 
from shoply_merchant_api import ShoplyMerchantClient
 
 
with ShoplyMerchantClient(
    store_key=os.environ["SHOPLY_STORE_KEY"],
    api_secret=os.environ["SHOPLY_STORE_OWNER_API_SECRETE"],
) as shoply:
    session_response = shoply.list_sessions(limit=40)
 
for conversation in session_response.data:
    print(conversation.customer_id, conversation.user_questions)

Pakiet udostępnia także funkcje dla analityki, liczników aktywności, pełnych osi czasu sesji, strefy czasowej sklepu i zarządzania wiedzą. Zobacz jego przewodnik po zastosowaniach biznesowych  oraz dokumentację API .

Pakiet Node.js i TypeScript

Repozytorium shoply-merchant-api-js udostępnia pakiet @shoplyai/merchant-api dla Node.js 20 lub nowszego. Jest to pakiet ESM z wbudowanymi deklaracjami TypeScript i bez zależności uruchomieniowych. Zainstaluj przypięte wydanie 2.1.3 bezpośrednio z GitHub:

npm install "github:shoplyai-public/shoply-merchant-api-js#v2.1.3"

Pobierz te same najnowsze sesje z serwera Node.js:

import { ShoplyMerchantClient } from "@shoplyai/merchant-api";
 
const storeKey = process.env.SHOPLY_STORE_KEY;
const apiSecret = process.env.SHOPLY_STORE_OWNER_API_SECRETE;
if (!storeKey || !apiSecret) {
  throw new Error("SHOPLY_STORE_KEY and SHOPLY_STORE_OWNER_API_SECRETE are required");
}
 
const shoply = new ShoplyMerchantClient({
  storeKey,
  apiSecret,
});
 
const sessionResponse = await shoply.listSessions({ limit: 40 });
 
for (const conversation of sessionResponse.data) {
  console.log(conversation.customer_id, conversation.user_questions);
}

Pakiet npm obejmuje te same endpointy Merchant API co pakiet Python. Zobacz jego przewodnik po zastosowaniach biznesowych  oraz dokumentację API .

Oba pakiety są przeznaczone dla zaufanych usług backendowych, zadań harmonogramowanych i prywatnych narzędzi wewnętrznych. Nie importuj żadnego z tych pakietów do kodu storefrontu ani nie ujawniaj sekretu API w pakiecie przeglądarkowym.

Czy mogę wywoływać HTTP API bez pakietu?

Tak. Merchant API pozostaje standardowym API HTTPS. Poniższe niskopoziomowe przykłady w Pythonie używają Requests, aby pokazać pełny kontrakt komunikacyjny lub umożliwić integrację z innego języka.

Zainstaluj Requests, jeśli Twoje środowisko jeszcze go nie zawiera:

python -m pip install requests

Poniższa funkcja pomocnicza dodaje klucz sklepu i nagłówek uwierzytelniania do każdego żądania:

import json
import os
from typing import Any
 
import requests
 
BASE_URL = "https://api.shoplyai.ai"
STORE_KEY = os.environ["SHOPLY_STORE_KEY"]
STORE_OWNER_API_SECRETE = os.environ["SHOPLY_STORE_OWNER_API_SECRETE"]
 
session = requests.Session()
session.headers.update({
    "Authorization": json.dumps({
        "store_key": STORE_KEY,
        "store_owner_api_secrete": STORE_OWNER_API_SECRETE,
    })
})
 
 
def shoply_get(api_name: str, **params: Any) -> dict[str, Any]:
    """Call one store-scoped Shoply API and surface HTTP or API-level errors."""
    response = session.get(
        f"{BASE_URL}/{api_name}",
        params={"store_key": STORE_KEY, **params},
        timeout=30,
    )
    response.raise_for_status()
 
    payload = response.json()
    if payload.get("error") is not None or payload.get("statusCode") not in (None, 200):
        raise RuntimeError(payload.get("error", "Shoply API request failed"))
    return payload
 
 
def shoply_post(
    api_name: str,
    payload: dict[str, Any] | None = None,
    **params: Any,
) -> dict[str, Any]:
    """Write store-scoped data and surface HTTP or API-level errors."""
    response = session.post(
        f"{BASE_URL}/{api_name}",
        params={"store_key": STORE_KEY, **params},
        json=payload,
        timeout=60,
    )
    response.raise_for_status()
 
    result = response.json()
    if result.get("error") is not None or result.get("statusCode") not in (None, 200):
        raise RuntimeError(result.get("error", "Shoply API request failed"))
    return result

Poniższe przykłady używają tego współdzielonego klienta. Obie funkcje pomocnicze automatycznie dodają uwierzytelniony klucz sklepu.

Czy mogę zarządzać wiedzą Shoply AI przez API?

Tak. admin_store_knowledge używa GET do pobierania wiedzy oraz POST do jej tworzenia, aktualizowania, usuwania lub ponownego indeksowania. POST, który używa istniejącego identyfikatora wiedzy, aktualizuje ten wpis; użycie nowego identyfikatora tworzy nowy wpis.

Zanim zautomatyzujesz aktualizacje, zaplanuj użyteczną wiedzę sklepu korzystając z przykładów w naszym przewodniku szkoleniowym.

Zapisy wiedzy mogą zmieniać odpowiedzi wyświetlane klientom. Używaj dedykowanego sekretu dla systemu zarządzającego wiedzą, waliduj treść przed wysłaniem i nigdy nie ujawniaj tego poświadczenia z uprawnieniami zapisu w JavaScript storefrontu.

Wyświetlanie istniejącej wiedzy

knowledge_payload = shoply_get(
    "admin_store_knowledge",
    knowledge_id_to_retrieve="_ALL_",
)
 
for knowledge_id, knowledge in knowledge_payload["data"].items():
    print(knowledge_id, knowledge.get("title"))

Przykładowa odpowiedź

{
  "data": {
    "knowledge::shipping-policy": {
      "title": "Shipping policy",
      "text": "Orders leave our warehouse within two business days.",
      "epoch_edit": 1787211246
    }
  }
}

Tworzenie lub aktualizowanie niestandardowej wiedzy tekstowej

Wybierz stabilny, unikalny identyfikator wiedzy. Używaj ponownie tego samego identyfikatora podczas aktualizowania tego wpisu.

from time import time
 
knowledge_id = "knowledge::shipping-policy"
result = shoply_post(
    "admin_store_knowledge",
    {
        knowledge_id: {
            "title": "Shipping policy",
            "text": (
                "Orders leave our warehouse within two business days. "
                "Standard delivery normally takes three to five business days."
            ),
            "epoch_edit": int(time()),
        }
    },
)
 
print(result)

Przykładowa odpowiedź

{
  "statusCode": 200
}

Pomyślna odpowiedź oznacza, że wiedza została zapisana. Indeksowanie wyszukiwania może potrwać kilka minut, więc nowa odpowiedź może nie pojawić się od razu. Jeśli API zgłasza, że treść została zapisana, ale indeksowanie jest opóźnione, potwierdź zapisany wpis za pomocą GET przed ponowną próbą zapisu.

Dodawanie zewnętrznej strony internetowej

Użyj identyfikatora zaczynającego się od external_url::. Umieść pełny adres URL http:// lub https:// w polu text.

from time import time
 
result = shoply_post(
    "admin_store_knowledge",
    {
        "external_url::returns-policy": {
            "title": "Returns and exchanges",
            "text": "https://www.example.com/policies/returns",
            "epoch_edit": int(time()),
        }
    },
)

Przesyłanie i rejestrowanie pliku wiedzy

Pliki wiedzy muszą być w formacie PDF, TXT lub Markdown i mieć mniej niż 5 MB. Najpierw prześlij plik, a następnie zapisz zwróconą prywatną lokalizację S3 jako wpis wiedzy.

from pathlib import Path
from time import time
 
file_path = Path("shipping-policy.md")
with file_path.open("rb") as file_handle:
    upload_response = session.post(
        f"{BASE_URL}/user_generated_file",
        params={"store_key": STORE_KEY, "folder": "knowledge_file"},
        files={"file": (file_path.name, file_handle, "text/markdown")},
        timeout=60,
    )
 
upload_response.raise_for_status()
uploaded = upload_response.json()
if uploaded.get("statusCode") != 200:
    raise RuntimeError(uploaded.get("error", "Knowledge file upload failed"))
 
shoply_post(
    "admin_store_knowledge",
    {
        "knowledge_file::shipping-policy": {
            "title": "Shipping policy document",
            "text": uploaded["file_url"],
            "epoch_edit": int(time()),
        }
    },
)

Przykładowa odpowiedź przesyłania

{
  "message": "File uploaded successfully",
  "statusCode": 200,
  "file_url": "s3://shoplystores/your-store.myshopify.com/uploads/shipping-policy.md"
}

Traktuj file_url jako nieprzezroczystą prywatną lokalizację zwróconą przez Shoply. Nie twórz jej samodzielnie ani jej nie zmieniaj.

Usuwanie wiedzy

Usunięcie jest trwałe. Najpierw pobierz bieżące wpisy i wysyłaj tylko dokładne identyfikatory, które zamierzasz usunąć.

result = shoply_post(
    "admin_store_knowledge",
    {
        "knowledge_ids_to_delete": [
            "knowledge::shipping-policy",
            "external_url::returns-policy",
            "knowledge_file::shipping-policy",
        ]
    },
)

Żądanie ponownego przeszukania strony internetowej

Użyj ponownego przeszukania po zmianie treści na stronie sprzedawcy. Zwykle nie jest to konieczne po każdej aktualizacji niestandardowego tekstu.

result = shoply_post(
    "admin_store_knowledge",
    re_crawl_ind="true",
)

Zastosowania biznesowe

• Synchronizowanie wskazówek dotyczących wysyłki, zwrotów, gwarancji, rozmiarów lub pielęgnacji produktów z wewnętrznego systemu treści.
• Publikowanie tymczasowych informacji o kampaniach lub świętach bez ręcznego kopiowania ich do Shoply Admin.
• Dodawanie strony z polityką lub zatwierdzonego dokumentu do bazy wiedzy jako części procesu wdrożeniowego.
• Usuwanie nieaktualnych wskazówek natychmiast po zakończeniu polityki lub promocji.

Przykłady Merchant API

1. Pobieranie analityki wydajności

admin_store_analytics zasila tabelę Analytics → Summary. Zwraca sesje, czaty, wyszukiwania, kliknięcia, zdarzenia dodania do koszyka, zakupy i przypisany przychód.

Endpoint

GET https://api.shoplyai.ai/admin_store_analytics

Parametry zapytania

Raporty miesięczne używają zapisanej miesięcznej historii Shoply i nie wymagają zakresu dat.

Przykład w Pythonie

daily_report = shoply_get(
    "admin_store_analytics",
    report_type="daily",
    start_date="20260801",
    end_date="20260820",
)
 
for row in daily_report["data"]:
    print(row["date"], row["sessions"], row["purchases"], row["revenue"])
 
print("Totals:", daily_report["totals"])
 
# Weekly rows use the Monday of each week as their date label.
weekly_report = shoply_get(
    "admin_store_analytics",
    report_type="weekly",
    start_date="20260701",
    end_date="20260820",
)
 
# Monthly requests do not need start_date or end_date.
monthly_report = shoply_get("admin_store_analytics", report_type="monthly")

Przykładowa odpowiedź

{
  "data": [
    {
      "date": "20260820",
      "sessions": 42,
      "chats": 18,
      "searches": 24,
      "clicks": 11,
      "add_to_cart": 5,
      "purchases": 2,
      "revenue": "$168.00",
      "revenue_usd": "$168.00"
    }
  ],
  "totals": {
    "date": "totals",
    "sessions": 42,
    "chats": 18,
    "searches": 24,
    "clicks": 11,
    "add_to_cart": 5,
    "purchases": 2,
    "revenue": "$168.00",
    "revenue_usd": "$168.00"
  },
  "report_type": "daily"
}

Przychód może zawierać więcej niż jedną walutę. Traktuj revenue jako tekst do wyświetlania. Używaj revenue_usd, gdy potrzebujesz znormalizowanej wartości w USD wyświetlanej przez Shoply.

Zastosowania biznesowe

• Wysyłanie dziennego podsumowania wpływu na sprzedaż do sprzedawcy lub zespołu ecommerce.
• Porównywanie wyszukiwań, kliknięć produktów, zdarzeń dodania do koszyka i zakupów w celu znalezienia spadków w lejku.
• Zasilanie tygodniowego lub miesięcznego panelu business intelligence bez scrapowania strony Shoply Admin.
• Śledzenie przypisanego przychodu w czasie i porównywanie go ze zmianami merchandisingowymi lub kampanijnymi.

2. Pobieranie strefy czasowej sklepu

admin_get_store_metadata dostarcza oznaczenie strefy czasowej wyświetlane w Analytics → Chat & Search History. Strona używa go do przeliczania aktywności UTC na czas lokalny sklepu.

Endpoint

GET https://api.shoplyai.ai/admin_get_store_metadata

Parametry zapytania

Przykład w Pythonie

timezone_payload = shoply_get(
    "admin_get_store_metadata",
    metadata_key="time_zone",
)
 
timezone = timezone_payload["data"]
print(timezone["ianaTimezone"], timezone["timezoneOffsetMinutes"])

Przykładowa odpowiedź

{
  "data": {
    "ianaTimezone": "America/Los_Angeles",
    "timezoneOffset": -7,
    "timezoneOffsetMinutes": -420
  },
  "statusCode": 200
}

Zastosowania biznesowe

• Grupowanie aktywności UTC do tych samych lokalnych dni kalendarzowych, które sprzedawca widzi w Analytics.
• Planowanie dziennych eksportów po zakończeniu lokalnego dnia sklepu.
• Oznaczanie raportów jednoznaczną strefą czasową IANA, taką jak America/Los_Angeles.

Przesunięcia stref czasowych mogą się zmieniać z powodu zasad czasu letniego. Jeśli Twój system raportowania to obsługuje, preferuj ianaTimezone zamiast trwale zapisywać jedno przesunięcie liczbowe.

3. Pobieranie liczników aktywności

query_api_usage_count zwraca aktywność sklepu pogrupowaną według daty UTC lub oryginalnej minuty UTC. Jest także źródłem wykresu aktywności w Analytics → Chat & Search History.

Endpoint

GET https://api.shoplyai.ai/query_api_usage_count

Parametry zapytania

Przykład w Pythonie

activity = shoply_get(
    "query_api_usage_count",
    start_dt_utc="2026-08-01 00:00:00",
    end_dt_utc="2026-08-20 23:59:59",
    groupby="utc_date",
)
 
for row in activity["data"]:
    print(row)

Przykładowa odpowiedź

{
  "data": [
    {
      "utc_date": "2026-08-20",
      "QA": 18,
      "CHAT": 18,
      "SEARCH": 20,
      "CACHED_SEARCH": 4,
      "PRODUCT_SEARCH": 22,
      "CLICK": 11,
      "ADD_TO_CART": 5,
      "CHECKOUT": 2
    }
  ]
}

Wiersze zawierają liczniki aktywności dostępne dla danego okresu, takie jak pytania na czacie, wyszukiwania, kliknięcia, zdarzenia dodania do koszyka i zdarzenia checkoutu. Liczniki bez aktywności mogą być pominięte zamiast ustawione na zero.

Zastosowania biznesowe

• Budowanie godzinowego lub dziennego wykresu aktywności, podobnego do tego w Chat & Search History.
• Wykrywanie nietypowych skoków ruchu lub nagłych spadków zaangażowania klientów.
• Porównywanie wolumenu wyszukiwań produktów z kliknięciami, zdarzeniami dodania do koszyka i checkoutami.
• Szacowanie, kiedy zespoły wsparcia i merchandisingu powinny przeglądać najbardziej intensywne okresy.

4. Pobieranie podsumowań sesji czatu i wyszukiwania

query_sessionized_chat zwraca jeden zwarty rekord na sesję klienta. Zasila także listę sesji w Analytics → Chat & Search History.

Endpoint

GET https://api.shoplyai.ai/query_sessionized_chat

Parametry zapytania

Pobieranie najnowszych 40 sesji

summary_payload = shoply_get(
    "query_sessionized_chat",
    start_dt_utc="undefined",
    end_dt_utc="undefined",
    num_sessions=40,
    ScanIndexForward="false",
)
 
sessions = summary_payload["data"]
for conversation in sessions:
    print(conversation["customer_id"], conversation.get("user_questions", ""))

Pobieranie sesji w zakresie UTC

summary_payload = shoply_get(
    "query_sessionized_chat",
    start_dt_utc="2026-08-20 00:00:00",
    end_dt_utc="2026-08-20 23:59:59",
    ScanIndexForward="false",
)

Gdy obecne są oba ograniczenia czasowe, API zwraca sesje z pełnego zakresu; num_sessions nie ogranicza tego zapytania z określonym zakresem.

Przykładowa odpowiedź

{
  "data": [
    {
      "customer_id": "customer-or-session-id",
      "user_questions": "Do you have this in blue?\nWhen will it ship?",
      "start_timestamp_ms": 1787184000000,
      "end_timestamp_ms": 1787184065000,
      "session_types": "product information, click",
      "customer_email": null,
      "customer_info": {},
      "sentiment": "positive",
      "num_questions": 2,
      "num_searches": 1,
      "num_clicks": 1
    }
  ]
}

Pola opcjonalne różnią się w zależności od sesji. Zachowaj customer_id, start_timestamp_ms i end_timestamp_ms, jeśli planujesz pobrać pełną oś czasu.

Zastosowania biznesowe

• Przeglądanie próbki ostatnich rozmów pod kątem jakości odpowiedzi i szkolenia zespołu wsparcia.
• Znajdowanie powtarzających się pytań klientów, które powinny wpływać na opisy produktów lub FAQ.
• Identyfikowanie sesji o wysokiej intencji zawierających wyszukiwania, kliknięcia produktów lub inne działania zakupowe.
• Eksportowanie jednego wiersza na sesję do analizy trendów przy jednoczesnym uniknięciu większego ładunku danych na poziomie zdarzeń.

5. Pobieranie jednej pełnej sesji

Przekaż wybrane podsumowanie do query_log_visualization, aby pobrać zdarzenia klienta, AI, wyszukiwania i handlowe.

Endpoint

GET https://api.shoplyai.ai/query_log_visualization

Parametry zapytania

Przykład w Pythonie

from datetime import datetime, timezone
 
 
def utc_from_milliseconds(timestamp_ms: int) -> str:
    """Format a Shoply millisecond timestamp for the history API."""
    value = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
    return value.strftime("%Y-%m-%d %H:%M:%S")
 
 
selected = sessions[0]
timeline_payload = shoply_get(
    "query_log_visualization",
    date_time_utc_start=utc_from_milliseconds(selected["start_timestamp_ms"]),
    date_time_utc_end=utc_from_milliseconds(selected["end_timestamp_ms"]),
    session_id=selected["customer_id"],
    start_timestamp_ms=selected["start_timestamp_ms"],
)
 
for event in timeline_payload["data"]:
    print(event.get("server_timestamp_ms"), event.get("action_type"))

Przykładowa odpowiedź

{
  "data": [
    {
      "action_type": "QA",
      "session_id": "customer-or-session-id",
      "utc_date_time": "2026-08-20 00:00:00",
      "start_timestamp_ms": 1787184000000,
      "server_timestamp_ms": 1787184000123,
      "Q": {
        "question": "Do you have this in blue?",
        "question_context": {}
      },
      "task_id": "task-id",
      "list_tokens": [
        {
          "data_type": "LLMOutput",
          "data": "Yes. These blue options are currently available."
        }
      ],
      "dict_search_results": {}
    }
  ]
}

Oś czasu może zawierać pytania klientów, odpowiedzi AI, wyniki wyszukiwania, kliknięcia produktów, zdarzenia dodania do koszyka, zdarzenia checkoutu oraz udział ludzkiego agenta. Używaj server_timestamp_ms, aby porządkować mieszane typy zdarzeń. Starsze rekordy mogą zawierać mniej pól.

Zastosowania biznesowe

• Audytowanie dokładnie tego, o co pytał klient i co odpowiedziało Shoply podczas analizy zgłoszenia wsparcia.
• Przeglądanie jakości odpowiedzi wraz z wynikami wyszukiwania i produktami pokazanymi klientowi.
• Odtwarzanie ścieżki od pytania do kliknięcia, dodania do koszyka lub checkoutu.
• Diagnozowanie jednej sesji zgłoszonej przez klienta bez przeszukiwania niezwiązanej historii.

Czy mogę używać jednego sekretu do każdego API?

Tak. Prawidłowy store_owner_api_secrete jest przypisany do jednego sklepu i działa we wszystkich powyższych endpointach Merchant API. W przypadku kont SiteChat ten sam sekret uwierzytelnia także API przesyłania katalogu. Dla bezpieczniejszej pracy używaj oddzielnych nazwanych sekretów dla oddzielnych systemów — na przykład jednego do nocnego eksportu danych, a drugiego do wewnętrznego panelu.

Jeśli jedna integracja zostanie wycofana lub naruszona, unieważnij tylko jej sekret w ustawieniach Shoply. Pozostałe integracje będą nadal działać.

Co powinienem wiedzieć o wygaśnięciu, prywatności i błędach?

Zapoznaj się także z informacjami o źródłach danych i prywatności w Shoply, aby zrozumieć, jakie informacje są dostępne dla odpowiedzi udzielanych klientom.

• Sekrety API właściciela sklepu wygasają po 90 dniach. Utwórz zamiennik i zaktualizuj integrację przed datą wygaśnięcia.
• Standardowy okres przechowywania historii czatu i wyszukiwania w Shoply również wynosi 90 dni. Wygaśnięcie sekretu i retencja danych to oddzielne zasady.
• Odpowiedzi historii mogą zawierać dane osobowe, w tym identyfikatory klientów, adresy e-mail, przybliżoną lokalizację, pytania i aktywność zakupową. Przechowuj i przetwarzaj je zgodnie ze swoją polityką prywatności oraz obowiązującym prawem.
• HTTP 403 oznacza, że sekret jest brakujący, nieprawidłowy, wygasł, został unieważniony lub należy do innego sklepu.
• HTTP 422 zwykle oznacza, że wymagany parametr zapytania nie został podany lub ma nieprawidłową nazwę.
• HTTP 500 lub odpowiedź z statusCode: 500 oznacza, że żądanie dotarło do Shoply, ale nie mogło zostać ukończone. Ponawiaj tymczasowe błędy z backoffem i skontaktuj się z nami, jeśli błąd będzie się powtarzał.
• Używaj ograniczonych zakresów UTC dla eksportów i zadań cyklicznych, aby odpowiedzi pozostały możliwe do obsłużenia.

Czy wyszukiwanie produktów jest częścią Merchant API?

Publiczne API wyszukiwania produktów Shoply ma inny model uwierzytelniania i inny kontrakt żądań. Zobacz Jak uzyskać dostęp do Shoply AI Search przez API, jeśli chcesz otrzymywać wyniki wyszukiwania produktów dla doświadczenia skierowanego do kupujących, a nie prywatnych danych sprzedawcy.

Czy sprzedawcy SiteChat mogą przesłać katalog produktów?

Tak. Konta SiteChat mogą przesyłać uporządkowane produkty i obrazy produktów przy użyciu tego samego sekretu API właściciela sklepu. Te endpointy katalogu są opisane osobno w artykule Jak przesłać swój katalog dla SiteChat. Sklepy Shopify nadal synchronizują produkty przez Shopify i nie korzystają z tych tras przesyłania.

Aby uzyskać pomoc przy integracji, skontaktuj się z Shoply AI.