Skip to main content
Lola Send’s architecture enforces a strict separation between the conversational AI layer and payment card handling. Raw card data — PAN, CVV, expiry — never enters the chat channel, is never processed by AI agents, and is never stored in conversation state or Redis. All card operations occur in authenticated web widgets that integrate with PCI-compliant card vault infrastructure.

​
Card data never enters chat

The separation between conversation and card data is enforced at multiple levels:
  • No agent prompt instructs or allows collection of card numbers, CVV, or expiry dates in conversation. Agent system prompts explicitly scope the conversation to non-sensitive data collection — destination, amount, recipient, payout method.
  • get_payment_methods() returns display names only — the tool function returns card identifiers such as “Visa ending 1234”, never raw card numbers, CVV, or expiry dates. Agents present these display names for the sender to select a saved payment method.
  • Card entry happens exclusively in the external web widget — when a new card is required, the agent generates an authenticated short link. The sender opens the link in their browser and enters card details in the widget’s PCI-scoped environment.
The conversational AI layer has zero exposure to raw card data at any point in the transaction lifecycle.

​
Tokenized card handling

Card data that returns from the web widget to Lola Send’s backend is always tokenized:
  • Callback payloads from the widget contain tokenized card references (e.g., tok_sandbox_...), not raw card numbers
  • Card security codes are also tokenized in callback payloads
  • Sealed responses use Base64-encoded encrypted payloads for sensitive card-related data (ANI/AVS verification responses)
  • The backend processes tokenized references exclusively — it never receives or stores raw card numbers from the widget flow

​
Card vaulting

The web widget integrates with card vault infrastructure (VGS or equivalent tokenization provider) using a proxy-based architecture:
1

Card capture in PCI-scoped iframe

The sender enters card details into the widget’s PCI-scoped iframe. Raw card data exists only within this isolated browser context.
2

Direct transmission to vault

Raw card data is sent directly from the sender’s browser to the vault provider. It does not traverse Lola Send’s network, API servers, or any middleware.
3

Token returned to widget

The vault provider returns a token representing the card. The widget receives only this token — the raw card data has already been captured and secured by the vault.
4

Token submitted via callback

The widget submits the token (not the raw card data) to Lola Send’s encrypted callback URL. The backend processes the operation using the token.
This proxy-based approach means raw card data never traverses Lola Send’s network. It flows directly from the sender’s browser to the vault provider’s PCI-certified infrastructure.

​
PCI DSS scope reduction

Because raw card data is captured and vaulted entirely outside Lola Send’s agentic layer:
  • The conversational infrastructure — Celai, agents, Redis, middleware — operates outside PCI DSS scope
  • The web widget is the only component in the PCI boundary, and it delegates card capture to the vault provider’s PCI-certified infrastructure
  • Lola Send’s backend handles only tokenized references, which are not considered cardholder data under PCI DSS
This architectural separation minimizes the bank’s PCI compliance burden for the conversational channel.

​
Separation of concerns

LayerResponsibilityCard data access
Chat (Celai)Conversation orchestration, data collection, quotingNone — display names only
Web widgetCIP verification, card authorizationTokenized — raw data sent directly to vault
Card vault (VGS)Card capture, tokenization, storageFull — PCI-certified infrastructure
BackendOperation execution using tokensTokenized references only
Each layer in the stack has the minimum card data access required for its function. The conversational layer has none. The widget handles only tokens. Only the PCI-certified vault touches raw card data.