Come usare l’API Merchant di Shoply

L’API Merchant di Shoply consente a un merchant di utilizzare in modo sicuro i propri dati Shoply in strumenti di reporting, flussi di supporto, esportazioni pianificate e applicazioni aziendali private.

Ogni integrazione si autentica con una credenziale revocabile, limitata al negozio, creata nelle Impostazioni di Shoply. Non è necessario condividere un token di accesso Shopify Admin API e un’integrazione può accedere solo al negozio che ha emesso la propria credenziale.

Cosa posso fare con l’API Merchant?

Puoi usare l’API Merchant per:

• Esportare risultati giornalieri, settimanali o mensili delle prestazioni in un foglio di calcolo o in un data warehouse.
• Creare una dashboard privata per sessioni, chat, ricerche, clic sui prodotti, eventi di aggiunta al carrello, acquisti e ricavi attribuiti.
• Monitorare l’attività dei clienti e individuare cambiamenti insoliti nel coinvolgimento.
• Esaminare sessioni di chat e di ricerca per attività di supporto, merchandising e qualità delle risposte.
• Recuperare la timeline di una singola conversazione quando indaghi su un problema di un cliente.
• Creare, aggiornare, elencare ed eliminare la knowledge personalizzata usata da Shoply AI.
• Aggiungere una pagina web esterna o un file PDF, di testo o Markdown caricato alla knowledge base.
• Allineare i dati evento UTC al fuso orario locale del negozio.

Questa guida documenta sette endpoint. Cinque sono gli stessi endpoint usati da Shoply Admin → Analytics, mentre due gestiscono la knowledge base:

I corpi di risposta qui sotto sono esempi rappresentativi. I tuoi campi e valori rifletteranno l’attività registrata per il tuo negozio.

Requisito di deployment: l’autenticazione con secret del proprietario del negozio deve essere distribuita sul server API che stai chiamando. Se un secret valido restituisce HTTP 403 con No access_token found, quel server sta ancora eseguendo il vecchio codice di autenticazione basato solo su access token.

Come creo un secret API?

1. Apri il tuo admin di Shoply AI.
2. Vai su Settings → Store owner API secret.
3. Crea un secret e assegnagli un nome che identifichi l’integrazione, ad esempio Weekly reporting export.
4. Copia il secret quando appare. Shoply mostra il valore in chiaro una sola volta.

Ogni secret è valido per 90 giorni. Un negozio può avere secret separati per integrazioni separate e puoi revocare un secret senza interrompere gli altri.

Salva questi valori come variabili d’ambiente lato server:

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

Usa il dominio permanente myshopify.com del negozio per SHOPLY_STORE_KEY, anche se normalmente gli acquirenti visitano un dominio personalizzato.

Come funziona l’autenticazione?

Ogni richiesta all’API Merchant invia un header Authorization il cui valore è una stringa JSON:

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

store_owner_api_secrete è il nome esatto del campo pubblico, inclusa la sua grafia storica. Non è un token Bearer. Inserisci direttamente la stringa JSON completa nell’header Authorization.

Mantieni il secret solo nel codice backend. Non inserirlo in un URL, in un bundle del browser, in un repository pubblico, in un evento analytics o nel log dell’applicazione.

Esistono pacchetti ufficiali Python e Node.js?

Sì. Shoply pubblica due pacchetti server-side che aggiungono automaticamente l’autenticazione richiesta ed espongono l’API Merchant come funzioni tipizzate. Entrambi i pacchetti sono open source nell’organizzazione GitHub shoplyai-public.

Pacchetto Python

Il pacchetto shoply-merchant-api supporta Python 3.12 e usa modelli di risposta Pydantic v2. Installa la release 2.1.3 bloccata:

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"

Recupera le sessioni di chat e ricerca più recenti come modelli tipizzati 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)

Il pacchetto fornisce anche funzioni per analytics, conteggi delle attività, timeline complete delle sessioni, fuso orario del negozio e gestione della knowledge. Consulta la sua guida ai casi d’uso aziendali  e il riferimento API .

Pacchetto Node.js e TypeScript

Il repository shoply-merchant-api-js fornisce il pacchetto @shoplyai/merchant-api per Node.js 20 o versioni successive. È un pacchetto ESM con dichiarazioni TypeScript integrate e nessuna dipendenza runtime. Installa direttamente da GitHub la release 2.1.3 bloccata:

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

Recupera le stesse sessioni più recenti da un server 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);
}

Il pacchetto npm copre gli stessi endpoint dell’API Merchant del pacchetto Python. Consulta la sua guida ai casi d’uso aziendali  e il riferimento API .

Entrambi i pacchetti sono destinati a servizi backend affidabili, job pianificati e strumenti interni privati. Non importare nessuno dei due pacchetti nel codice storefront e non esporre il secret API in un bundle del browser.

Posso chiamare l’API HTTP senza un pacchetto?

Sì. L’API Merchant rimane una normale API HTTPS. Gli esempi Python di basso livello qui sotto usano Requests così puoi vedere il contratto completo a livello di rete o integrare da un altro linguaggio.

Installa Requests se il tuo ambiente non lo include già:

python -m pip install requests

L’helper qui sotto aggiunge la chiave del negozio e l’header di autenticazione a ogni richiesta:

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

Gli esempi qui sotto usano questo client condiviso. Entrambi gli helper aggiungono automaticamente la chiave del negozio autenticata.

Posso gestire la knowledge di Shoply AI tramite API?

Sì. admin_store_knowledge usa GET per recuperare la knowledge e POST per crearla, aggiornarla, eliminarla o richiederne una nuova scansione. Un POST che usa un ID di knowledge esistente aggiorna quella voce; usarne uno nuovo ne crea una.

Prima di automatizzare gli aggiornamenti, pianifica una knowledge del negozio utile con gli esempi nella nostra guida al training.

Le scritture sulla knowledge possono modificare le risposte mostrate agli acquirenti. Usa un secret dedicato per il sistema che gestisce la knowledge, valida il contenuto prima di inviarlo e non esporre mai questa credenziale con permessi di scrittura nel JavaScript dello storefront.

Elencare la knowledge esistente

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"))

Risposta di esempio

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

Creare o aggiornare knowledge di testo personalizzato

Scegli un ID di knowledge stabile e univoco. Riutilizza lo stesso ID quando aggiorni quella voce.

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)

Risposta di esempio

{
  "statusCode": 200
}

Una risposta con esito positivo significa che la knowledge è stata salvata. L’indicizzazione per la ricerca può richiedere alcuni minuti, quindi una nuova risposta potrebbe non apparire immediatamente. Se l’API segnala che il contenuto è stato salvato ma l’indicizzazione è in ritardo, conferma la voce memorizzata con GET prima di ritentare la scrittura.

Aggiungere una pagina web esterna

Usa un ID che inizi con external_url::. Inserisci l’URL completo http:// o https:// in 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()),
        }
    },
)

Caricare e registrare un file di knowledge

I file di knowledge devono essere PDF, TXT o Markdown e inferiori a 5 MB. Carica prima il file, poi salva la posizione privata S3 restituita come voce di knowledge.

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()),
        }
    },
)

Risposta di esempio del caricamento

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

Tratta file_url come una posizione privata opaca restituita da Shoply. Non costruirla né modificarla manualmente.

Eliminare knowledge

L’eliminazione è permanente. Recupera prima le voci correnti e invia solo gli ID esatti che intendi rimuovere.

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

Richiedere una nuova scansione del sito web

Usa una nuova scansione dopo che il contenuto sul sito web del merchant è cambiato. Normalmente non è necessaria dopo ogni aggiornamento di testo personalizzato.

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

Casi d’uso aziendali

• Sincronizzare indicazioni su spedizione, resi, garanzia, taglie o cura del prodotto da un sistema di contenuti interno.
• Pubblicare informazioni temporanee su campagne o festività senza copiarle manualmente in Shoply Admin.
• Aggiungere una pagina web di policy o un documento approvato alla knowledge base come parte di un flusso di deployment.
• Rimuovere indicazioni obsolete non appena termina una policy o una promozione.

Esempi di API Merchant

1. Recuperare analytics delle prestazioni

admin_store_analytics alimenta la tabella Analytics → Summary. Restituisce sessioni, chat, ricerche, clic, eventi di aggiunta al carrello, acquisti e ricavi attribuiti.

Endpoint

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

Parametri di query

I report mensili usano la cronologia mensile memorizzata da Shoply e non richiedono limiti di data.

Esempio Python

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")

Risposta di esempio

{
  "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"
}

Il ricavo può contenere più di una valuta. Tratta revenue come testo di visualizzazione. Usa revenue_usd quando ti serve il valore normalizzato in USD mostrato da Shoply.

Casi d’uso aziendali

• Inviare un riepilogo giornaliero dell’impatto sulle vendite al merchant o al team ecommerce.
• Confrontare ricerche, clic sui prodotti, eventi di aggiunta al carrello e acquisti per trovare punti di abbandono nel funnel.
• Alimentare una dashboard di business intelligence settimanale o mensile senza fare scraping della pagina Shoply Admin.
• Monitorare nel tempo i ricavi attribuiti e confrontarli con modifiche di merchandising o campagne.

2. Recuperare il fuso orario del negozio

admin_get_store_metadata fornisce il badge del fuso orario mostrato in Analytics → Chat & Search History. La pagina lo usa per tradurre l’attività UTC nell’ora locale del negozio.

Endpoint

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

Parametri di query

Esempio Python

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

Risposta di esempio

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

Casi d’uso aziendali

• Raggruppare l’attività UTC negli stessi giorni di calendario locali che il merchant vede in Analytics.
• Pianificare esportazioni giornaliere dopo la fine della giornata locale del negozio.
• Etichettare i report con un fuso orario IANA non ambiguo come America/Los_Angeles.

Gli offset del fuso orario possono cambiare a causa delle regole sull’ora legale. Preferisci ianaTimezone quando il tuo sistema di reporting lo supporta invece di salvare permanentemente un singolo offset numerico.

3. Recuperare i conteggi delle attività

query_api_usage_count restituisce l’attività del negozio raggruppata per data UTC o per minuto UTC originale. È anche la fonte del grafico attività in Analytics → Chat & Search History.

Endpoint

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

Parametri di query

Esempio Python

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)

Risposta di esempio

{
  "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
    }
  ]
}

Le righe includono i contatori di attività disponibili per quel periodo, come domande in chat, ricerche, clic, eventi di aggiunta al carrello ed eventi di checkout. I contatori senza attività potrebbero essere assenti invece di essere impostati a zero.

Casi d’uso aziendali

• Creare un grafico delle attività orarie o giornaliere come quello in Chat & Search History.
• Rilevare picchi di traffico insoliti o cali improvvisi del coinvolgimento dei clienti.
• Confrontare il volume di ricerca prodotti con clic, eventi di aggiunta al carrello e checkout.
• Stimare quando i team di supporto e merchandising dovrebbero esaminare i periodi di maggiore attività.

4. Recuperare i riepiloghi delle sessioni di chat e ricerca

query_sessionized_chat restituisce un record compatto per ogni sessione cliente. Alimenta anche l’elenco sessioni in Analytics → Chat & Search History.

Endpoint

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

Parametri di query

Recuperare le ultime 40 sessioni

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", ""))

Recuperare sessioni in un intervallo 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",
)

Quando entrambi i limiti temporali sono presenti, l’API restituisce le sessioni nell’intervallo completo; num_sessions non limita quella query delimitata.

Risposta di esempio

{
  "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
    }
  ]
}

I campi facoltativi variano in base alla sessione. Conserva customer_id, start_timestamp_ms e end_timestamp_ms se prevedi di recuperare la timeline completa.

Casi d’uso aziendali

• Esaminare un campione di conversazioni recenti per qualità delle risposte e formazione del supporto.
• Trovare domande ricorrenti dei clienti che dovrebbero influenzare il copy di prodotto o le FAQ.
• Identificare sessioni ad alta intenzione che contengono ricerche, clic sui prodotti o altre azioni di acquisto.
• Esportare una riga per sessione per l’analisi dei trend evitando il payload più grande a livello di evento.

5. Recuperare una sessione completa

Passa un riepilogo selezionato a query_log_visualization per recuperarne gli eventi del cliente, dell’AI, di ricerca e di commercio.

Endpoint

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

Parametri di query

Esempio Python

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"))

Risposta di esempio

{
  "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": {}
    }
  ]
}

La timeline può contenere domande dei clienti, risposte dell’AI, risultati di ricerca, clic sui prodotti, eventi di aggiunta al carrello, eventi di checkout e partecipazione di operatori umani. Usa server_timestamp_ms per ordinare tipi di evento misti. I record più vecchi possono contenere meno campi.

Casi d’uso aziendali

• Verificare esattamente cosa ha chiesto un cliente e cosa ha risposto Shoply durante un’indagine di supporto.
• Esaminare la qualità delle risposte insieme ai risultati di ricerca e ai prodotti mostrati all’acquirente.
• Ricostruire il percorso dalla domanda al clic, all’aggiunta al carrello o al checkout.
• Diagnosticare una sessione segnalata da un cliente senza cercare nella cronologia non correlata.

Posso usare un solo secret per ogni API?

Sì. Un store_owner_api_secrete valido è limitato a un solo negozio e funziona su tutti gli endpoint dell’API Merchant sopra indicati. Per gli account SiteChat, lo stesso secret autentica anche le API di caricamento catalogo. Per operazioni più sicure, usa secret nominati separati per sistemi diversi, ad esempio uno per un’esportazione dati notturna e un altro per una dashboard interna.

Se un’integrazione viene dismessa o compromessa, revoca solo il suo secret in Shoply Settings. Le altre integrazioni continueranno a funzionare.

Cosa devo sapere su scadenza, privacy ed errori?

Consulta anche le fonti dei dati e la privacy di Shoply per capire quali informazioni sono disponibili per le risposte ai clienti.

• I secret API del proprietario del negozio scadono dopo 90 giorni. Crea un sostituto e aggiorna l’integrazione prima della data di scadenza.
• Anche il periodo standard di conservazione della cronologia di chat e ricerca di Shoply è di 90 giorni. La scadenza del secret e la conservazione dei dati sono policy separate.
• Le risposte della cronologia possono contenere dati personali, inclusi identificatori cliente, indirizzi email, posizione approssimativa, domande e attività di acquisto. Archiviali ed elaborali in conformità con la tua informativa sulla privacy e la legge applicabile.
• HTTP 403 significa che il secret è mancante, non valido, scaduto, revocato o appartiene a un altro negozio.
• HTTP 422 di solito significa che manca un parametro di query obbligatorio o che ha un nome errato.
• HTTP 500 o una risposta con statusCode: 500 significa che la richiesta ha raggiunto Shoply ma non ha potuto essere completata. Riprova gli errori temporanei con backoff e contattaci se l’errore continua.
• Usa intervalli UTC delimitati per esportazioni e job ricorrenti in modo che le risposte restino gestibili.

La ricerca prodotti fa parte dell’API Merchant?

L’API pubblica di ricerca prodotti di Shoply ha un’autenticazione e un contratto di richiesta diversi. Consulta Come accedere alla ricerca Shoply AI tramite API se vuoi risultati di ricerca prodotti per un’esperienza rivolta agli acquirenti invece che dati privati del merchant.

I merchant SiteChat possono caricare un catalogo prodotti?

Sì. Gli account SiteChat possono caricare prodotti strutturati e immagini prodotto con lo stesso secret API del proprietario del negozio. Questi endpoint del catalogo sono documentati separatamente in Come caricare il tuo catalogo per SiteChat. I negozi Shopify continuano a sincronizzare i prodotti tramite Shopify e non usano quei percorsi di upload.

Per ricevere aiuto con un’integrazione, contatta Shoply AI.