Add payments to your agent

npm install @stripe/link-sdk

go get github.com/stripe/link-cli/packages/sdk-go

pip install stripe-link-sdk

import Link from '@stripe/link-sdk'
 
const link = new Link({
  getAccessToken: async ({ forceRefresh } = {}) =>
    credentialManager.getLinkAccessToken({ forceRefresh }),
})

client, err := link.NewClient(link.Options{
	GetAccessToken: func(
		ctx context.Context,
		options link.GetAccessTokenOptions,
	) (string, error) {
		return credentialManager.LinkAccessToken(ctx, options.ForceRefresh)
	},
})
if err != nil {
	return err
}

from link import Client, GetAccessTokenOptions
 
 
def get_token(options: GetAccessTokenOptions) -> str:
    return credential_manager.link_access_token(force_refresh=options.force_refresh)
 
 
client = Client(get_access_token=get_token)

const methods = await link.paymentMethods.list()
const eligibleMethods = methods.filter(
  (method) => method.capabilities?.agentic_payments?.eligible !== false,
)
const paymentMethod =
  eligibleMethods.find((method) => method.is_default) ?? eligibleMethods[0]
 
if (!paymentMethod) {
  throw new Error('The user needs to add an eligible Link payment method.')
}

methods, err := client.PaymentMethods.List(ctx)
if err != nil {
	return err
}
var paymentMethod *link.PaymentMethod
for index := range methods {
	capability, exists := methods[index].Capabilities["agentic_payments"]
	if exists && !capability.Eligible {
		continue
	}
	if paymentMethod == nil || methods[index].IsDefault {
		paymentMethod = &methods[index]
	}
}
if paymentMethod == nil {
	return errors.New("the user needs to add an eligible Link payment method")
}

methods = client.payment_methods.list()
eligible_methods = [
    method
    for method in methods
    if (method.capabilities or {})
    .get("agentic_payments", {})
    .get("eligible")
    is not False
]
payment_method = next(
    (method for method in eligible_methods if method.is_default),
    eligible_methods[0] if eligible_methods else None,
)
 
if payment_method is None:
    raise RuntimeError("The user needs to add an eligible Link payment method.")

const spendRequest = await link.spendRequests.create({
  payment_details: paymentMethod.id,
  credential_type: 'card',
  amount: 2599,
  currency: 'usd',
  merchant_name: 'Acme',
  merchant_url: 'https://acme.example',
  context:
    'The user asked the agent to buy the selected item from Acme for $25.99, including the displayed shipping cost.',
})

amount := int64(2599)
currency := "usd"
credentialType := link.CredentialTypeCard
merchantName := "Acme"
merchantURL := "https://acme.example"
 
spendRequest, err := client.SpendRequests.Create(ctx, link.CreateSpendRequestParams{
	PaymentDetails: &paymentMethod.ID,
	CredentialType: &credentialType,
	Amount:         &amount,
	Currency:       &currency,
	MerchantName:   &merchantName,
	MerchantURL:    &merchantURL,
	Context:        "The user asked the agent to buy the selected item from Acme for $25.99, including the displayed shipping cost.",
})
if err != nil {
	return err
}

spend_request = client.spend_requests.create(
    payment_details=payment_method.id,
    credential_type="card",
    amount=2599,
    currency="usd",
    merchant_name="Acme",
    merchant_url="https://acme.example",
    context=(
        "The user asked the agent to buy the selected item from Acme for $25.99, "
        "including the displayed shipping cost."
    ),
)

const approval = await link.spendRequests.requestApproval(spendRequest.id)
const approvalDeadline = Date.now() + 30 * 60 * 1000
 
await sendToUser(`Approve this purchase: ${approval.approval_url}`)
await saveRunState({ spendRequestId: spendRequest.id, approvalDeadline })

approval, err := client.SpendRequests.RequestApproval(ctx, spendRequest.ID)
if err != nil {
	return err
}
 
sendToUser(fmt.Sprintf("Approve this purchase: %s", approval.ApprovalURL))
saveRunState(spendRequest.ID, time.Now().Add(30*time.Minute))

approval = client.spend_requests.request_approval(spend_request.id)
approval_deadline = time.time() + 30 * 60
 
send_to_user(f"Approve this purchase: {approval.approval_url}")
save_run_state(spend_request.id, approval_deadline)

const nonce = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString('base64url')
await saveRunState({ nonce })
 
const spendRequest = await link.spendRequests.create({
  // ...the purchase fields from the previous example
  completion_callback_url: 'https://agent.example.com/link/callback',
  nonce,
})

callbackURL := "https://agent.example.com/link/callback"
nonce := newOpaqueNonce() // At least 128 bits from a cryptographically secure source.
saveRunState(nonce)
 
spendRequest, err := client.SpendRequests.Create(ctx, link.CreateSpendRequestParams{
	// ...the purchase fields from the previous example
	CompletionCallbackURL: &callbackURL,
	Nonce:                 &nonce,
})

nonce = secrets.token_urlsafe(32)
save_run_state(nonce=nonce)
 
spend_request = client.spend_requests.create(
    # ...the purchase fields from the previous example
    completion_callback_url="https://agent.example.com/link/callback",
    nonce=nonce,
)

if (result.status !== 'approved') {
  await notifyUser(`Purchase not approved: ${result.status}`)
  return
}
 
const approved = await link.spendRequests.retrieve(result.id, {
  include: ['card'],
})
 
if (!approved?.card) {
  throw new Error('Approved spend request did not include a card.')
}
 
await checkoutWorker.complete(approved.card)

if result.Status != link.SpendRequestStatusApproved {
	notifyUser(fmt.Sprintf("Purchase not approved: %s", result.Status))
	return nil
}
 
approved, err := client.SpendRequests.Retrieve(
	ctx,
	result.ID,
	&link.RetrieveSpendRequestParams{Include: []string{"card"}},
)
if err != nil {
	return err
}
if approved == nil || approved.Card == nil {
	return errors.New("approved spend request did not include a card")
}
 
return checkoutWorker.Complete(ctx, approved.Card)

if result.status != "approved":
    notify_user(f"Purchase not approved: {result.status}")
    return
 
approved = client.spend_requests.retrieve(result.id, include=["card"])
if approved is None or approved.card is None:
    raise RuntimeError("Approved spend request did not include a card.")
 
checkout_worker.complete(approved.card)