Members

A member is one person enrolled in a shop’s membership programme: their tier, their usable points and store credit, their coupons, and a small amount of behavioural summary (how many visits, when they last came). This is the resource a CRM, a loyalty engine or a customer-analytics warehouse reads.

Three endpoints:

• GET /v1/members — a page of members for one membership base
• GET /v1/members/{memberToken} — one member by token
• GET /v1/members/lookup — the member token behind a LINE user id you already hold

All three are read-only.

Membership in ScanFood does not belong to a shop — it belongs to a membership base, identified by providerId. Several branches routinely share one base, so a customer who joined at one branch is recognised at every branch that shares it.

That is why this endpoint is scoped by providerId and not by shopId.

providerId is required on the list endpoint, and it must be one your key covers — otherwise you get 403 provider_not_in_scope. Get the list of values you are allowed to use from GET /v1/shops.

What is stored about a member is far more than what is returned: the underlying record holds their messaging account, phone, email, birthday, gender, photos, free-text notes, full visit history with per-visit amounts, and every points and credit movement. The API returns a fixed, hand-picked subset — see Privacy.

Members are identified by an opaque token that always begins with m1_:

m1_ZmQ3YjJkNGE1ZTZmNzg5MGExYjJjM2Q0ZTVmNjc4OTBhYmNkZWYxMjM

The token is the only identifier this API exposes for a person. It replaces the internal record id, which is built from the customer’s messaging account and would leak their real identity if it were handed out.

What you can rely on:

The memberId on a bill is exactly this token, so bill-to-member joins need no translation step:

// A bill from /v1/transactions
if (bill.memberId) {
  const member = await getMember(bill.memberId); // /v1/members/{memberToken}
}

If you already hold a customer’s LINE user id — because they are talking to your bot, or opened your LIFF app — you can exchange it for that person’s member token without asking them for anything:

• GET /v1/members/lookup — one member token, from a LINE user id

GET /ext/v1/members/lookup?providerId=pv3Yh9DkQ2sLmT6RwX1B&lineUserId=U4af4980629…

The answer is the token and nothing else:

{
  "ok": true,
  "data": {
    "memberId": "m1_ZmQ3YjJkNGE1ZTZmNzg5MGExYjJjM2Q0ZTVmNjc4OTBhYmNkZWYxMjM"
  },
  "serverTime": "2026-09-18T04:10:00.000Z"
}

It is the same token as everywhere else — so GET /v1/members/{memberToken} gives you tier, points and coupons, and every bill in GET /v1/transactions carrying that memberId is a purchase by the same person. This is the “a customer just messaged us — are they a member, and who are they to us?” case.

Note the direction of travel: you supply a LINE user id you already have, and get a token back. The API still does not hand a LINE user id out — hasLine remains the only thing a member response says about that channel.

Lookup is off by default and enabled per key, the same way tel and email are (see Privacy). A key without it gets 403 lookup_not_enabled on every call. Turning it on is a commercial and legal decision about lawful basis and consent under Thailand’s personal data protection law, not a technical toggle — ask your ScanFood contact, and expect to say what the lookup will be used for.

curl -s -G https://api.scanfood.co/ext/v1/members/lookup \
  -H "Authorization: Bearer sf_live_4b8f2c1e9d07_3f9a2c1b7e4d8506a1b2c3d4e5f60718" \
  --data-urlencode "providerId=pv3Yh9DkQ2sLmT6RwX1B" \
  --data-urlencode "lineUserId=U4af4980629304a1b8c2d3e4f5a6b7c8d"

const BASE = 'https://api.scanfood.co/ext/v1';
const KEY = process.env.SCANFOOD_API_KEY;

/** LINE user id -> member token, or null when there is no match. */
async function lookupMember(providerId, lineUserId) {
  const url = new URL(`${BASE}/members/lookup`);
  url.searchParams.set('providerId', providerId);
  url.searchParams.set('lineUserId', lineUserId);

  const res = await fetch(url, { headers: { Authorization: `Bearer ${KEY}` } });
  if (res.status === 404) return null; // not a member of this brand
  const body = await res.json();
  if (!res.ok) throw new Error(`${res.status} ${body.error}: ${body.message}`);
  return body.data.memberId;
}

// On an inbound chat message — cache the result, do not call per message.
const token = await lookupMember('pv3Yh9DkQ2sLmT6RwX1B', event.source.userId);
if (token) {
  const member = await getMember(token); // /v1/members/{memberToken}
  console.log(member.rankName, member.points);
}

import os
import requests

BASE = "https://api.scanfood.co/ext/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['SCANFOOD_API_KEY']}"}


def lookup_member(provider_id, line_user_id):
    """LINE user id -> member token, or None when there is no match."""
    res = requests.get(
        f"{BASE}/members/lookup",
        headers=HEADERS,
        params={"providerId": provider_id, "lineUserId": line_user_id},
        timeout=60,
    )
    if res.status_code == 404:
        return None  # not a member of this brand
    body = res.json()
    if res.status_code != 200:
        raise RuntimeError(f"{res.status_code} {body['error']}: {body['message']}")
    return body["data"]["memberId"]


token = lookup_member("pv3Yh9DkQ2sLmT6RwX1B", event.source.user_id)
if token:
    member = get_member(token)  # /v1/members/{memberToken}
    print(member["rankName"], member["points"])

If someone signed up more than once and holds several records in the same membership base, the lookup answers with the most recently created one.

Response envelope for the list endpoint:

{
  "ok": true,
  "data": [ { "…": "one object per member" } ],
  "nextCursor": "m1_…",
  "serverTime": "2026-09-10T01:45:00.000Z"
}

The single-member endpoint returns the same object under data with no nextCursor.

Two further fields appear only for keys explicitly granted personal-data access (see Privacy):

Fields deliberately absent: the member’s name and nickname, phone and email (unless granted), messaging account id, birthday, gender, photos, address, free-text notes, saved cards, the raw visit history, and the raw points and credit movement lists. There is also no loyalty segment (Loyal, At-Risk, New and so on) — those are computed in batch elsewhere and are not attached to the member record. Derive them yourself from visitCount, lastVisit and transaction history.

coupons[] is the member’s coupon wallet. Each entry:

Two things worth planning for:

• A coupon with status: "used" stays in the wallet. Filter on status before you show “coupons available”.
• status describes redemption, not expiry. Treat expireAt as a separate condition and compare it against serverTime rather than the clock on your own machine.

Coupons are always read within the membership base you asked for, so a coupon belonging to another brand can never appear in the wallet.

There is no incremental mode for members. updatedSince is rejected with 400 not_supported.

So: page through the whole base with cursor.

Members come back ordered by sign-up date, oldest first, which makes a full pass stable: rows already returned do not jump ahead of you while you page. nextCursor is null on the last page.

# first page
curl -s -G https://api.scanfood.co/ext/v1/members \
  -H "Authorization: Bearer sf_live_4b8f2c1e9d07_3f9a2c1b7e4d8506a1b2c3d4e5f60718" \
  --data-urlencode "providerId=pv3Yh9DkQ2sLmT6RwX1B" \
  --data-urlencode "limit=200"

# next page — pass the nextCursor from the response above
curl -s -G https://api.scanfood.co/ext/v1/members \
  -H "Authorization: Bearer sf_live_4b8f2c1e9d07_3f9a2c1b7e4d8506a1b2c3d4e5f60718" \
  --data-urlencode "providerId=pv3Yh9DkQ2sLmT6RwX1B" \
  --data-urlencode "limit=200" \
  --data-urlencode "cursor=m1_ZmQ3YjJkNGE1ZTZmNzg5MGExYjJjM2Q0ZTVmNjc4OTBhYmNkZWYxMjM"

const BASE = 'https://api.scanfood.co/ext/v1';
const KEY = process.env.SCANFOOD_API_KEY;

async function getPage(path, params) {
  const url = new URL(`${BASE}${path}`);
  for (const [k, v] of Object.entries(params)) {
    if (v != null) url.searchParams.set(k, v);
  }
  const res = await fetch(url, { headers: { Authorization: `Bearer ${KEY}` } });
  const body = await res.json();
  if (!res.ok) throw new Error(`${res.status} ${body.error}: ${body.message}`);
  return body;
}

/** Full pass over one membership base. */
async function syncMembers(providerId, onMember) {
  let cursor = null;
  let seen = 0;

  do {
    const page = await getPage('/members', { providerId, limit: 200, cursor });
    for (const member of page.data) {
      onMember(member); // upsert on member.memberId
      seen += 1;
    }
    cursor = page.nextCursor;
    // Persist `cursor` here if you want to resume an interrupted run.
  } while (cursor);

  return seen;
}

const total = await syncMembers('pv3Yh9DkQ2sLmT6RwX1B', upsertMember);
console.log('synced', total, 'members');

// One member, straight from a bill
async function getMember(token) {
  const body = await getPage(`/members/${encodeURIComponent(token)}`, {});
  return body.data;
}

import os
import requests
from urllib.parse import quote

BASE = "https://api.scanfood.co/ext/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['SCANFOOD_API_KEY']}"}


def get_page(path, params=None):
    query = {k: v for k, v in (params or {}).items() if v is not None}
    res = requests.get(f"{BASE}{path}", headers=HEADERS, params=query, timeout=60)
    body = res.json()
    if res.status_code != 200:
        raise RuntimeError(f"{res.status_code} {body['error']}: {body['message']}")
    return body


def sync_members(provider_id, on_member):
    """Full pass over one membership base."""
    cursor, seen = None, 0
    while True:
        page = get_page("/members", {
            "providerId": provider_id,
            "limit": 200,
            "cursor": cursor,
        })
        for member in page["data"]:
            on_member(member)  # upsert on member["memberId"]
            seen += 1
        cursor = page["nextCursor"]
        # Persist `cursor` here if you want to resume an interrupted run.
        if not cursor:
            return seen


total = sync_members("pv3Yh9DkQ2sLmT6RwX1B", upsert_member)
print("synced", total, "members")


def get_member(token):
    """One member, straight from a bill."""
    return get_page(f"/members/{quote(token, safe='')}")["data"]

If a cursor points at a member who has since been removed, you get 400 bad_cursor. Restart that page without a cursor rather than treating it as a fatal error.

{
  "ok": true,
  "data": [
    {
      "memberId": "m1_ZmQ3YjJkNGE1ZTZmNzg5MGExYjJjM2Q0ZTVmNjc4OTBhYmNkZWYxMjM",
      "rank": "GOLD",
      "rankLevel": 2,
      "rankName": "โกลด์",
      "points": 14097,
      "credit": 200,
      "creditEnabled": true,
      "coupons": [
        {
          "code": "ABC123",
          "status": "available",
          "templateId": "cp7Vb2NqZ5tMx8LwR3Kd",
          "name": "ส่วนลด 50 บาท",
          "expireAt": "2026-12-31T23:59:59.000+07:00"
        },
        {
          "code": "XYZ789",
          "status": "used",
          "templateId": "cpQ4mL8vT2zNb6RwK9Ys",
          "name": "ฟรีชาเย็น",
          "expireAt": null
        }
      ],
      "labels": ["vip", "แพ้ถั่ว"],
      "persona": ["สายหวาน"],
      "createdDate": "2026-03-04T16:15:00.000+07:00",
      "visitCount": 57,
      "lastVisit": "2026-09-07",
      "hasTel": true,
      "hasEmail": false,
      "hasLine": true
    }
  ],
  "nextCursor": null,
  "serverTime": "2026-09-10T01:45:00.000Z"
}

Membership data is personal data, and this API is built so that a key cannot accidentally acquire more of it than it was given.

By default, no contact details are returned at all. You get hasTel, hasEmail and hasLine — enough to know whether a channel exists and to segment on it — but not the values.

Phone and email can be switched on per key, and only those two fields; there is no setting that opens anything else. A third, separate flag opens member lookup — and note what that flag does and does not do: it lets a key send in a LINE user id it already holds and receive a member token. It does not add the messaging account id to any response. No key level ever reads one out of ScanFood. Turning them on is a commercial and legal decision about lawful basis and consent under Thailand’s personal data protection law, not a technical toggle — ask your ScanFood contact, and expect to say what the data will be used for.

Everything else about the person stays inside ScanFood permanently:

• Transactions — memberId on a bill points straight at a member.
• Shops — where providerId comes from.
• Pagination and sync — cursor rules in detail.
• Errors — every code these endpoints can return.
• Security best practices.