← library
Review-gated, no OAuth
Payments / wallet — merchant integration (no third-party OAuth data API)·agent-generated · deepseek-v4.1-flash·checked 2026-10-28
difficulty
3/5

No OAuth to authorize Google Pay: it is a merchant-side API where the payment sheet returns a gateway token, and going live needs a Google Pay & Wallet Console business profile plus manual website review (AI screenshot pre-check, then human; duration undocumented).

First working connection
~1-4 hours for a TEST-mode integration (inferred); merchant profile + gateway account adds 1-3 days (inferred)
Production / approved
~1-2 weeks (inferred): 1-5 days of website review plus PSP onboarding; approval duration is not documented in the sources
Composio managed OAuth
Bring your own app
Not in Composio's managed-OAuth list — you'll need your own OAuth app (or it isn't a Composio toolkit yet).
who does itagent 3you 6provider 0
evidencetested 2sourced 22inferred 13
◆ agent run11 pages read18/29 quotes verified verbatim45s$0.023deepseek-v4.1-flash

01Pick your path

Gateway tokenization
when You already have (or will open) a merchant account with a participating PSP listed in the gateway table.
→ No PCI scope for you; encrypted card token goes to the processor. Gated only by the Google Pay website review.
DIRECT tokenization
when You are PCI DSS compliant and want to handle cardholder data without a gateway.
→ You receive encrypted card data yourself: PCI DSS compliance, annual key rotation, and PCI Attestation submitted in the console.
Identity only (Google OAuth/OIDC)
when The agent only needs to know who the user is, e.g. to link accounts around a checkout.
→ You get an ID token (sub, email) you can use for account linking. Zero access to Google Pay cards, transactions, or payment initiation.

02Time & effort

Hands-on work
~1 workdays – ~4 workdays
Waiting on others
1 day – 5 days
You're actually working
21% of elapsed time
Phases
6
start↑ first working connection, then production pathproduction
  1. DEVChoose path & draft config20–60 minutessourced[S4][S5]Agent can draft the decision memo, baseRequest, PaymentDataRequest and scope list; you confirm the payment gateway.
  2. DEVMerchant & console setup1–3 daysinferred[S3][S9]PSP onboarding time is not documented in these sources; business verification is yours to complete.
  3. DEVBuild TEST integration1–3 hourssourced[S4][S5][S7]Steps 1-9 of the web tutorial: version, tokenization, allowed methods, pay.js, isReadyToPay, button, PaymentDataRequest, click handler.
  4. DEVChecklist testing2–4 hourssourced[S7]Basics, brand, functional tests across browsers plus Android/iOS device tests.
  5. PRODWebsite integration reviewwait 1–5 daysinferred[S9]Duration is not stated in the sources. AI gives immediate screenshot feedback, then a manual review by the Google Pay team.
  6. PRODFlip to PRODUCTION10–30 minutessourced[S9]Set merchantInfo.merchantId and environment 'PRODUCTION', then ship.
agent can do it you waiting on providerbar widths ∝ √time, so short tasks stay visible

03Steps

0/9 done

Get a working connection

  1. Pin down what you actually need: pay button vs sign-inagentinferred[S3][S4][S9]

    The agent can't 'authorize' Google Pay. The only OAuth here is Google identity (openid email profile). Payment data comes from the Google Pay API payment sheet, keyed by a merchant ID, and is gated by console review, not scopes. Write that down before coding — it changes the whole design.

  2. Choose tokenization methodyouinferred[S3][S9]

    Pick Gateway (participating PSP) or DIRECT (PCI DSS). Gateway is the low-friction path. Have the agent draft the memo with the gateway name and the console integration type so the human reviewer sees consistency.

    ◆ prepared by agent · Decision memo (agent-drafted)
    GOOGLE PAY — INTEGRATION DECISION
    Goal: agent-adjacent checkout (no OAuth data access requested)
    Path: Gateway tokenization
    - Gateway: <PSP from Google's table>
    - Integration type in console: Gateway
    - OAuth scopes requested: none (Google Pay has none)
    - Identity (optional, separate project): openid, email
    - Production gate: Google Pay & Wallet Console website review
    - Out of scope: reading user's saved cards/transactions (no documented API)
  3. Create the Google Pay business profileyousourced ❝[S9]

    Google Pay & Wallet Console → Type of business: Merchant → complete Business Profile → Google Pay API tab → Get Started → accept ToS and Acceptable Use Policy. Merchant ID appears top-right. Requires your login and legal acceptance — not delegable.

    “Accept the Google Pay Terms of Service and Acceptable Use Policy.” — [S9] verified verbatim
  4. Build the web integration in TESTagentsourced ❝[S4][S5][S7]

    Follow tutorial steps 1-9: declare apiVersion 2/0, set the gateway tokenizationSpecification, list allowed card networks/auth methods, load pay.js, call isReadyToPay() before rendering the button, build PaymentDataRequest, call loadPaymentData() synchronously in the click handler. The agent can write all of it.

    “Follow the steps in this tutorial to integrate a web application with the Google Pay API, and to configure it to accept payment cards.” — [S4] verified verbatim
    ◆ prepared by agent · TEST-mode Google Pay request (agent-generated)
    const baseRequest = { apiVersion: 2, apiVersionMinor: 0 };
    
    const tokenizationSpecification = {
      type: 'PAYMENT_GATEWAY',
      parameters: { gateway: 'example', gatewayMerchantId: 'YOUR_GATEWAY_MERCHANT_ID' }
    };
    
    const paymentsClient = new google.payments.api.PaymentsClient({ environment: 'TEST' });
    
    const paymentDataRequest = {
      ...baseRequest,
      merchantInfo: { merchantName: 'Example Merchant' },
      allowedPaymentMethods: [{
        type: 'CARD',
        parameters: {
          allowedAuthMethods: ['PAN_ONLY', 'CRYPTOGRAM_3DS'],
          allowedCardNetworks: ['AMEX', 'DISCOVER', 'INTERAC', 'JCB', 'MASTERCARD', 'VISA']
        },
        tokenizationSpecification
      }],
      transactionInfo: { totalPriceStatus: 'FINAL', totalPrice: '12.34', currencyCode: 'USD' },
      emailRequired: true
    };
  5. Clear the integration checklistyousourced ❝[S7]

    Run the integration checklist: risk/3DS parity for PAN_ONLY, brand assets and button sizing, button only after isReadyToPay(), no pop-up blocking, cards-on-file test, Android device-token test, shipping/email parsing. Test on Chrome, Firefox, Safari, Edge, Android and iOS.

    “Use the following checklist to ensure you've completed all the required steps in your web integration.” — [S7] verified verbatim
  6. Optional: add Google Identity OAuth in a separate projectagentsourced ❝[S1][S8][S10]

    Only if you truly need the user's Google identity: register a Web application OAuth client in the Cloud Console, set an authorized redirect URI (http://localhost:8080 works for testing), keep client_secret.json out of the repo, and request the narrowest scopes. Separate test and production projects. This yields an ID token, not payment access.

    “For testing, you can specify URIs that refer to the local machine, such as http://localhost:8080.” — [S1] verified verbatim

Make it production-ready

  1. Submit the website for reviewyousourced ❝[S9]

    Console → Google Pay API > Integrations > Integrate with your website > Add website. Give the top-level domain, select Integration type Gateway (or Direct), upload screenshots of the working Google Pay flow, Save, then Submit for approval. AI gives instant screenshot feedback; a human makes the final call.

    “In the Google Pay & Wallet Console, navigate to Google Pay API > Integrations > Integrate with your website section and click Add website.” — [S9] verified verbatim
  2. Publish with merchant ID + PRODUCTIONyousourced ❝[S9][S5]

    Set merchantInfo.merchantId from the console, initialize PaymentsClient with environment 'PRODUCTION', and ship. No OAuth token exchange, no scope verification, no consent-screen review is involved on the Pay side.

    “Initialize PaymentsClient with an object that includes an environment property set to 'PRODUCTION'.” — [S9] verified verbatim
  3. DIRECT path only: key rotation + PCI attestationyousourced ❝[S7]

    If you went DIRECT: rotate the public encryption key annually and submit PCI Attestation via the Google Pay & Wallet Console, from a QSA or third party. Gateway integrators skip this entirely.

    “If you complete a DIRECTtokenizationSpecificationtype integration, you must annually rotate your public encryption key and provide PCI Attestation to Google using the Google Pay & Wallet Console.” — [S7] verified verbatim

04Requirements, scopes & nuances

You'll need

  • ▸A Google Cloud project plus a Google Pay & Wallet Console business profile (Type of business = Merchant) with the Google Pay ToS and Acceptable Use Policy accepted. sourced ❝[S9]
  • ▸A supported payment gateway, or a PCI DSS compliant environment if you choose DIRECT. sourced ❝[S9]
  • ▸A top-level domain that calls the Google Pay API, registered under Google Pay API > Integrations > Integrate with your website. sourced ❝[S9]
  • ▸Website screenshots showing the working Google Pay integration, uploaded with the submission. sourced ❝[S9][S7]
  • ▸A Google account on a business email domain (e.g. admin@yourdomain.com) for registration. sourced ❝[S7]
  • ▸For production, the merchant ID from the console (merchantInfo.merchantId) and PaymentsClient initialized with environment 'PRODUCTION'. sourced ❝[S9]

Gotchas

  • !Payment data never arrives as an OAuth grant. The payment sheet returns a tokenized card to your gateway (PAYMENT_GATEWAY) or to you as encrypted data (DIRECT); email/shipping are opt-in fields on the request object, not scopes. inferred[S4][S5]
  • !TEST environment returns non-chargeable dummy payment data. Passing local tests proves nothing about production approval. sourced ❝[S7]
  • !Brand rules are enforced: only render the Google Pay button after isReadyToPay() resolves, use approved assets, and match button sizing/background — these are checklist items reviewers verify. sourced ❝[S7]
  • !DIRECT tokenization obligates annual public-key rotation plus PCI Attestation submitted via the Google Pay & Wallet Console. sourced ❝[S7]
  • !Screenshots are screened by AI first, then by a human reviewer — a fast first signal, but still a manual gate you cannot automate. sourced ❝[S9]
  • !Google's OAuth verification regime (sensitive/restricted scopes, brand verification, annual re-verification, security assessment) is about Google user-data scopes. It only touches you if you separately request such scopes; it does not gate Google Pay. inferred[S2][S8][S10]
Scope / permissionTierNoteEvidence
openidbasicIn scopes_supported of the OpenID discovery document. Identity only — sign-in/account linking. Grants nothing in Google Pay.inferred[S1]
emailbasicSame document. Use it if the agent needs the user's address for receipts or account linking; checkout email can instead come from the payment sheet's emailRequired flag.inferred[S5]
profilebasicSame document. Basic name/picture; keep it out unless you actually display them.inferred[S1]
Google Pay payment access (no such OAuth scope)gatedNot a scope. Payment credentials come from the payment sheet as a gateway token (PAYMENT_GATEWAY) or DIRECT-encrypted data, keyed by merchantId. No OAuth grant to read a user's Google Pay cards, transactions, or to initiate payments appears in the Google Pay docs or in the OAuth scope reference.inferred[S4][S5][S9][S11]

05If you get blocked

✕Planner assumes Google Pay exposes an OAuth API a third-party agent can use to read a user's payment methods or pay on their behalf.inferred[S3][S4][S5][S9]

→ Drop the OAuth assumption. Build the merchant-side Google Pay API integration (TEST first), then use Google Pay & Wallet Console for production approval.

✕No payment gateway lined up, so tokenizationSpecification can't be filled in.inferred[S3][S4][S7]

→ Pick a participating processor from the list, or go DIRECT and submit PCI Attestation through the console.

✕Website submission rejected because the domain, integration type, or screenshots don't match the live integration.sourced ❝[S9][S7]

→ Register the top-level domain in Google Pay API > Integrations, select Gateway/Direct, upload screenshots of the working integration, then Submit for approval. If submitting more than 50 fully qualified domains, contact support first.

✕You also need the user's Google account identity (sign-in) and confuse it with Pay authorization.inferred[S1][S8][S10]

→ If you need identity, add Google Identity OIDC (openid email profile) as a separate concern in its own Cloud project; keep it out of the payment flow.

06Evidence: what was tested, sourced, and still uncertain

$ probes: live GETs with a dummy client_id, no credentials
✓ Discovery document (/.well-known/openid-configuration) → 200
https://accounts.google.com/.well-known/openid-configuration
issuer=https://accounts.google.com; authorization_endpoint=https://accounts.google.com/o/oauth2/v2/auth; token_endpoint=https://oauth2.googleapis.com/token; scopes_supported=openid email profile
∴ accounts.google.com is the standard Google OAuth/OIDC issuer — the same one used for Sign in with Google. It is not a Google Pay data API; the metadata only advertises openid/email/profile-style identity scopes. If your agent needs identity, these are the endpoints; if it needs payment data, this is the wrong door.
✓ Authorize endpoint with a fake client_id → 302
https://accounts.google.com/o/oauth2/v2/auth?client_id=probe_invalid_client&response_type=code&redirect_uri=https%3A%2F%2Fexample.com%2Fcallback
redirect → https://accounts.google.com/signin/oauth/error?authError=Cg9pbnZhbGlkX3JlcXVlc3QSIU1pc3NpbmcgcmVxdWlyZWQgcGFyYW1ldGVyOiBzY29wZRo3aHR0cHM6Ly9kZXZlbG9wZXJzLmdvb2d (authError decodes to: invalid_request !Missing required parameter: scope 7https://developers.google.com/identity/protocols)

Still uncertain

  • ? Review turnaround for the Google Pay website submission is not stated in any source; my 1-5 day estimate is inferred from the described AI pre-check + manual review.
  • ? I found no Google Pay OAuth/data API in these sources. A partner-only or bank-side API may exist (transaction history, issuer/PSP integrations) but nothing in S3-S9 documents it — verify directly with the Google Pay team before committing.
  • ? S11 (scope reference) was truncated in the fetch, so 'no Google Pay scope exists' rests on the absence in the Pay docs plus the section shown, not on a complete listing.
  • ? The discovery document's scopes_supported field is OIDC metadata (openid/email/profile), not the full Google scope catalog; per-API scopes are granted separately.
  • ? PSP onboarding and PCI DSS attestation timelines are not documented here and depend entirely on your provider.
  • ? Generated automatically; no app was registered and no review was submitted.