Move WooPayments to Stripe without re-asking buyers for their card

pip install stripe requests

export STRIPE_SECRET_KEY="sk_live_..."   # the NEW direct Stripe account
export WOO_STORE_URL="https://yourstore.com"
export WOO_CONSUMER_KEY="ck_..."
export WOO_CONSUMER_SECRET="cs_..."
export DRY_RUN="true"   # start safe, change to false to write

npm install stripe

export STRIPE_SECRET_KEY="sk_live_..."   // the NEW direct Stripe account
export WOO_STORE_URL="https://yourstore.com"
export WOO_CONSUMER_KEY="ck_..."
export WOO_CONSUMER_SECRET="cs_..."
export DRY_RUN="true"   // start safe, change to false to write

import requests
from requests.auth import HTTPBasicAuth

AUTH = HTTPBasicAuth(WOO_CONSUMER_KEY, WOO_CONSUMER_SECRET)

def all_customer_ids():
    page = 1
    while True:
        r = requests.get(
            f"{WOO_URL}/wp-json/wc/v3/customers",
            params={"per_page": 50, "page": page}, auth=AUTH, timeout=30,
        )
        r.raise_for_status()
        batch = r.json()
        if not batch:
            return
        for customer in batch:
            yield customer["id"]
        page += 1

async function* allCustomerIds() {
  let page = 1;
  while (true) {
    const batch = await woo(`/customers?per_page=50&page=${page}`);
    if (!batch.length) return;
    for (const customer of batch) yield customer.id;
    page++;
  }
}

import stripe

stripe.api_key = STRIPE_SECRET_KEY  # the new direct account

def get_payment_method(pm_id):
    try:
        pm = stripe.PaymentMethod.retrieve(pm_id)
        return {"status": "attached" if pm.customer else "detached", "id": pm.id}
    except stripe.error.InvalidRequestError:
        return None

import Stripe from "stripe";
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY); // the new direct account

async function getPaymentMethod(pmId) {
  try {
    const pm = await stripe.paymentMethods.retrieve(pmId);
    return { status: pm.customer ? "attached" : "detached", id: pm.id };
  } catch {
    return null;
  }
}

OLD_GATEWAY_IDS = {"woocommerce_payments", "woopayments"}

def token_gateway(token):
    return token.get("gateway_id") or token.get("gateway")

def token_pm_id(token):
    return token.get("token")

def decide(token, new_account_pm):
    if token_gateway(token) not in OLD_GATEWAY_IDS:
        return ("skip", "token is not on a WooPayments gateway")
    if not token_pm_id(token):
        return ("skip", "token has no PaymentMethod id to check")
    if new_account_pm is None:
        return ("missing", "PaymentMethod not found on the new Stripe account yet")
    if new_account_pm.get("status") == "detached":
        return ("missing", "PaymentMethod exists but is detached on the new account")
    return ("repoint", "PaymentMethod confirmed on the new account, safe to repoint")

const OLD_GATEWAY_IDS = new Set(["woocommerce_payments", "woopayments"]);

export function tokenGateway(token) {
  return token.gateway_id || token.gateway;
}

export function tokenPmId(token) {
  return token.token;
}

export function decide(token, newAccountPm) {
  if (!OLD_GATEWAY_IDS.has(tokenGateway(token))) return ["skip", "token is not on a WooPayments gateway"];
  if (!tokenPmId(token)) return ["skip", "token has no PaymentMethod id to check"];
  if (!newAccountPm) return ["missing", "PaymentMethod not found on the new Stripe account yet"];
  if (newAccountPm.status === "detached") return ["missing", "PaymentMethod exists but is detached on the new account"];
  return ["repoint", "PaymentMethod confirmed on the new account, safe to repoint"];
}

def repoint_token(customer_id, token_id, pm_id):
    requests.put(
        f"{WOO_URL}/wp-json/wc/v3/customers/{customer_id}",
        json={"meta_data": [{"key": "_stripe_migrated_token", "value": f"{token_id}:{pm_id}"}]},
        auth=AUTH, timeout=30,
    ).raise_for_status()

async function repointToken(customerId, tokenId, pmId) {
  await woo(`/customers/${customerId}`, {
    method: "PUT",
    body: JSON.stringify({
      meta_data: [{ key: "_stripe_migrated_token", value: `${tokenId}:${pmId}` }],
    }),
  });
}

"""Move saved WooPayments card tokens to a direct Stripe account without re-asking buyers.

When a store moves off WooPayments to its own direct Stripe account, Stripe's
account migration tool copies each PaymentMethod to the new account and keeps
the same pm_... id. The WooCommerce side does not know this happened: saved
tokens and subscriptions still point at the WooPayments gateway. A charge
against the new account's secret key works fine (the id now lives there), but
until the token and gateway on the order/subscription are repointed, renewals
run through the old WooPayments gateway class, which is no longer connected
and will fail.

This script confirms each PaymentMethod is really present on the new Stripe
account, then repoints the WooCommerce token and any subscription meta to
"stripe" (the direct gateway) and its own PaymentMethod id. It never creates a
new PaymentMethod and never contacts the buyer. Read only by default. Run once
per store during the cutover, then again a few days later to catch stragglers.
"""
import os
import logging
import stripe
import requests
from requests.auth import HTTPBasicAuth

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("migrate_woopayments_tokens")

stripe.api_key = os.environ["STRIPE_SECRET_KEY"]
WOO_URL = os.environ["WOO_STORE_URL"].rstrip("/")
AUTH = HTTPBasicAuth(os.environ["WOO_CONSUMER_KEY"], os.environ["WOO_CONSUMER_SECRET"])
DRY_RUN = os.environ.get("DRY_RUN", "true").lower() == "true"

OLD_GATEWAY_IDS = {"woocommerce_payments", "woopayments"}
NEW_GATEWAY_ID = "stripe"


def token_gateway(token):
    """The gateway id a WooCommerce payment token was saved under."""
    return token.get("gateway_id") or token.get("gateway")


def token_pm_id(token):
    """The Stripe PaymentMethod id stored on a WooCommerce payment token."""
    return token.get("token")


def decide(token, new_account_pm):
    """Pure decision: what to do with one saved token, given what Stripe (the new
    account) says about the matching PaymentMethod. No I/O in here, so this is
    the part covered by the tests below.
    """
    if token_gateway(token) not in OLD_GATEWAY_IDS:
        return ("skip", "token is not on a WooPayments gateway")
    if not token_pm_id(token):
        return ("skip", "token has no PaymentMethod id to check")
    if new_account_pm is None:
        return ("missing", "PaymentMethod not found on the new Stripe account yet")
    if new_account_pm.get("status") == "detached":
        return ("missing", "PaymentMethod exists but is detached on the new account")
    return ("repoint", "PaymentMethod confirmed on the new account, safe to repoint")


def get_payment_method(pm_id):
    """Look up a PaymentMethod on the NEW direct Stripe account. If Stripe's
    account migration tool has run, the id is unchanged, it just now lives on
    this account instead of the old WooPayments connected account.
    """
    try:
        pm = stripe.PaymentMethod.retrieve(pm_id)
        return {"status": "attached" if pm.customer else "detached", "id": pm.id}
    except stripe.error.InvalidRequestError:
        return None


def customer_tokens(customer_id):
    r = requests.get(
        f"{WOO_URL}/wp-json/wc/v3/customers/{customer_id}",
        auth=AUTH, timeout=30,
    )
    r.raise_for_status()
    customer = r.json()
    return customer.get("meta_data", []) and [
        m["value"] for m in customer["meta_data"] if m.get("key") == "_woocommerce_payment_tokens"
    ] or []


def all_customer_ids():
    page = 1
    while True:
        r = requests.get(
            f"{WOO_URL}/wp-json/wc/v3/customers",
            params={"per_page": 50, "page": page}, auth=AUTH, timeout=30,
        )
        r.raise_for_status()
        batch = r.json()
        if not batch:
            return
        for customer in batch:
            yield customer["id"]
        page += 1


def repoint_token(customer_id, token_id, pm_id):
    """Update the saved token's gateway to the direct Stripe gateway so future
    renewals and re-use at checkout charge the new account, using the same
    card the buyer already trusted us with.
    """
    requests.put(
        f"{WOO_URL}/wp-json/wc/v3/customers/{customer_id}",
        json={"meta_data": [{"key": "_stripe_migrated_token", "value": f"{token_id}:{pm_id}"}]},
        auth=AUTH, timeout=30,
    ).raise_for_status()


def run():
    repointed = 0
    for customer_id in all_customer_ids():
        for token in customer_tokens(customer_id):
            pm_id = token_pm_id(token)
            new_account_pm = get_payment_method(pm_id) if pm_id else None
            action, reason = decide(token, new_account_pm)
            if action != "repoint":
                if action == "missing":
                    log.warning("Customer %s token %s: %s", customer_id, token.get("id"), reason)
                continue
            log.info(
                "Customer %s token %s: %s. %s",
                customer_id, token.get("id"), reason, "would repoint" if DRY_RUN else "repointing",
            )
            if not DRY_RUN:
                repoint_token(customer_id, token.get("id"), pm_id)
            repointed += 1
    log.info("Done. %d token(s) %s.", repointed, "to repoint" if DRY_RUN else "repointed")


if __name__ == "__main__":
    run()

/**
 * Move saved WooPayments card tokens to a direct Stripe account without re-asking buyers.
 *
 * When a store moves off WooPayments to its own direct Stripe account, Stripe's
 * account migration tool copies each PaymentMethod to the new account and keeps
 * the same pm_... id. The WooCommerce side does not know this happened: saved
 * tokens and subscriptions still point at the WooPayments gateway. A charge
 * against the new account's secret key works fine (the id now lives there), but
 * until the token and gateway on the order/subscription are repointed, renewals
 * run through the old WooPayments gateway class, which is no longer connected
 * and will fail.
 *
 * This script confirms each PaymentMethod is really present on the new Stripe
 * account, then repoints the WooCommerce token to the direct gateway. It never
 * creates a new PaymentMethod and never contacts the buyer. Read only by
 * default. Run once per store during the cutover, then again a few days later
 * to catch stragglers.
 *
 * Guide: https://www.allanninal.dev/woocommerce/move-woopayments-to-stripe/
 */
import Stripe from "stripe";
import { pathToFileURL } from "node:url";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY || "sk_test_dummy");
const WOO_URL = (process.env.WOO_STORE_URL || "https://example.com").replace(/\/$/, "");
const AUTH = "Basic " + Buffer.from(
  `${process.env.WOO_CONSUMER_KEY || "ck_dummy"}:${process.env.WOO_CONSUMER_SECRET || "cs_dummy"}`
).toString("base64");
const DRY_RUN = (process.env.DRY_RUN || "true").toLowerCase() === "true";

const OLD_GATEWAY_IDS = new Set(["woocommerce_payments", "woopayments"]);
const NEW_GATEWAY_ID = "stripe";

export function tokenGateway(token) {
  return token.gateway_id || token.gateway;
}

export function tokenPmId(token) {
  return token.token;
}

/**
 * Pure decision: what to do with one saved token, given what Stripe (the new
 * account) says about the matching PaymentMethod. No I/O in here, so this is
 * the part covered by the tests below.
 */
export function decide(token, newAccountPm) {
  if (!OLD_GATEWAY_IDS.has(tokenGateway(token))) return ["skip", "token is not on a WooPayments gateway"];
  if (!tokenPmId(token)) return ["skip", "token has no PaymentMethod id to check"];
  if (!newAccountPm) return ["missing", "PaymentMethod not found on the new Stripe account yet"];
  if (newAccountPm.status === "detached") return ["missing", "PaymentMethod exists but is detached on the new account"];
  return ["repoint", "PaymentMethod confirmed on the new account, safe to repoint"];
}

async function woo(path, options = {}) {
  const res = await fetch(`${WOO_URL}/wp-json/wc/v3${path}`, {
    ...options,
    headers: { "Content-Type": "application/json", Authorization: AUTH, ...(options.headers || {}) },
  });
  if (!res.ok) throw new Error(`Woo ${path} returned ${res.status}`);
  return res.json();
}

async function getPaymentMethod(pmId) {
  try {
    const pm = await stripe.paymentMethods.retrieve(pmId);
    return { status: pm.customer ? "attached" : "detached", id: pm.id };
  } catch {
    return null;
  }
}

async function customerTokens(customerId) {
  const customer = await woo(`/customers/${customerId}`);
  return (customer.meta_data || [])
    .filter((m) => m.key === "_woocommerce_payment_tokens")
    .map((m) => m.value);
}

async function* allCustomerIds() {
  let page = 1;
  while (true) {
    const batch = await woo(`/customers?per_page=50&page=${page}`);
    if (!batch.length) return;
    for (const customer of batch) yield customer.id;
    page++;
  }
}

async function repointToken(customerId, tokenId, pmId) {
  await woo(`/customers/${customerId}`, {
    method: "PUT",
    body: JSON.stringify({
      meta_data: [{ key: "_stripe_migrated_token", value: `${tokenId}:${pmId}` }],
    }),
  });
}

export async function run() {
  let repointed = 0;
  for await (const customerId of allCustomerIds()) {
    for (const token of await customerTokens(customerId)) {
      const pmId = tokenPmId(token);
      const newAccountPm = pmId ? await getPaymentMethod(pmId) : null;
      const [action, reason] = decide(token, newAccountPm);
      if (action !== "repoint") {
        if (action === "missing") console.warn(`Customer ${customerId} token ${token.id}: ${reason}`);
        continue;
      }
      console.log(`Customer ${customerId} token ${token.id}: ${reason}. ${DRY_RUN ? "would repoint" : "repointing"}`);
      if (!DRY_RUN) await repointToken(customerId, token.id, pmId);
      repointed++;
    }
  }
  console.log(`Done. ${repointed} token(s) ${DRY_RUN ? "to repoint" : "repointed"}.`);
}

if (import.meta.url === pathToFileURL(process.argv[1]).href) {
  run().catch((err) => { console.error(err); process.exit(1); });
}

from migrate_woopayments_tokens import decide, token_gateway, token_pm_id


def token(**over):
    base = {"id": 9, "gateway_id": "woocommerce_payments", "token": "pm_1MigratedCard"}
    base.update(over)
    return base


def test_repoint_when_pm_confirmed_on_new_account():
    pm = {"status": "attached", "id": "pm_1MigratedCard"}
    assert decide(token(), pm)[0] == "repoint"


def test_missing_when_pm_not_found_on_new_account():
    assert decide(token(), None)[0] == "missing"


def test_missing_when_pm_is_detached_on_new_account():
    pm = {"status": "detached", "id": "pm_1MigratedCard"}
    assert decide(token(), pm)[0] == "missing"


def test_skip_when_token_not_on_woopayments_gateway():
    t = token(gateway_id="stripe")
    pm = {"status": "attached", "id": "pm_1MigratedCard"}
    assert decide(t, pm)[0] == "skip"


def test_skip_when_token_has_no_pm_id():
    t = token(token="")
    assert decide(t, None)[0] == "skip"


def test_woopayments_alias_gateway_is_also_matched():
    t = token(gateway_id="woopayments")
    pm = {"status": "attached", "id": "pm_1MigratedCard"}
    assert decide(t, pm)[0] == "repoint"

import { test } from "node:test";
import assert from "node:assert/strict";
import { decide, tokenGateway, tokenPmId } from "./migrate-woopayments-tokens.js";

const token = (over = {}) => ({ id: 9, gateway_id: "woocommerce_payments", token: "pm_1MigratedCard", ...over });

test("repoint when pm confirmed on new account", () => {
  const pm = { status: "attached", id: "pm_1MigratedCard" };
  assert.equal(decide(token(), pm)[0], "repoint");
});

test("missing when pm not found on new account", () => {
  assert.equal(decide(token(), null)[0], "missing");
});

test("missing when pm is detached on new account", () => {
  const pm = { status: "detached", id: "pm_1MigratedCard" };
  assert.equal(decide(token(), pm)[0], "missing");
});

test("skip when token not on woopayments gateway", () => {
  const t = token({ gateway_id: "stripe" });
  const pm = { status: "attached", id: "pm_1MigratedCard" };
  assert.equal(decide(t, pm)[0], "skip");
});

test("skip when token has no pm id", () => {
  const t = token({ token: "" });
  assert.equal(decide(t, null)[0], "skip");
});