How to Integrate Bolt.new with Payoneer

1# .env — Payoneer API credentials
2# Received from Payoneer after developer access approval
3PAYONEER_PROGRAM_ID=your-program-id
4PAYONEER_USERNAME=your-api-username
5PAYONEER_API_KEY=your-api-key
6
7# API base URLs
8PAYONEER_API_BASE=https://api.sandbox.payoneer.com  # sandbox
9# PAYONEER_API_BASE=https://api.payoneer.com  # production
10
11# For Next.js server-side: process.env.PAYONEER_API_KEY
12# Never use VITE_ prefix or NEXT_PUBLIC_ — these are secret server-side credentials

1// lib/payoneer.ts — server-side only
2let cachedToken: { access_token: string; expires_at: number } | null = null;
3
4export async function getPayoneerToken(): Promise<string> {
5  // Return cached token if still valid (with 60s buffer)
6  if (cachedToken && Date.now() < cachedToken.expires_at - 60_000) {
7    return cachedToken.access_token;
8  }
9
10  const username = process.env.PAYONEER_USERNAME!;
11  const apiKey = process.env.PAYONEER_API_KEY!;
12  const programId = process.env.PAYONEER_PROGRAM_ID!;
13  const apiBase = process.env.PAYONEER_API_BASE!;
14
15  const credentials = Buffer.from(`${username}:${apiKey}`).toString('base64');
16
17  const response = await fetch(`${apiBase}/v4/oauth2/token`, {
18    method: 'POST',
19    headers: {
20      'Authorization': `Basic ${credentials}`,
21      'Content-Type': 'application/x-www-form-urlencoded',
22    },
23    body: new URLSearchParams({
24      grant_type: 'client_credentials',
25      scope: `read:payments write:payments read:payees write:payees`,
26    }),
27  });
28
29  if (!response.ok) {
30    throw new Error(`Payoneer auth failed: ${response.status} ${await response.text()}`);
31  }
32
33  const data = await response.json();
34  cachedToken = {
35    access_token: data.access_token,
36    expires_at: Date.now() + (data.expires_in * 1000),
37  };
38
39  return data.access_token;
40}
41
42export async function payoneerFetch(
43  path: string,
44  options: RequestInit = {}
45): Promise<Response> {
46  const token = await getPayoneerToken();
47  const apiBase = process.env.PAYONEER_API_BASE!;
48
49  return fetch(`${apiBase}${path}`, {
50    ...options,
51    headers: {
52      'Authorization': `Bearer ${token}`,
53      'Content-Type': 'application/json',
54      ...options.headers,
55    },
56  });
57}

1// app/api/payoneer/send-payment/route.ts
2import { NextResponse } from 'next/server';
3import { payoneerFetch } from '@/lib/payoneer';
4import { createClient } from '@supabase/supabase-js';
5
6export async function POST(request: Request) {
7  const {
8    payee_email,
9    amount,
10    currency = 'USD',
11    description,
12    internal_reference_id,
13  } = await request.json();
14
15  if (!payee_email || !amount || !internal_reference_id) {
16    return NextResponse.json(
17      { error: 'payee_email, amount, and internal_reference_id are required' },
18      { status: 400 }
19    );
20  }
21
22  const paymentPayload = {
23    client_reference_id: internal_reference_id,
24    description,
25    payee: {
26      id: {
27        type: 'email',
28        value: payee_email,
29      },
30    },
31    amount: {
32      value: amount,
33      currency,
34    },
35  };
36
37  const response = await payoneerFetch('/v4/payments', {
38    method: 'POST',
39    body: JSON.stringify(paymentPayload),
40  });
41
42  if (!response.ok) {
43    const errorData = await response.json().catch(() => ({}));
44    return NextResponse.json(
45      { error: 'Payoneer payment failed', details: errorData },
46      { status: response.status }
47    );
48  }
49
50  const paymentData = await response.json();
51
52  // Update Supabase record with Payoneer payment details
53  const supabase = createClient(
54    process.env.NEXT_PUBLIC_SUPABASE_URL!,
55    process.env.SUPABASE_SERVICE_ROLE_KEY!
56  );
57
58  await supabase
59    .from('payments')
60    .update({
61      payoneer_payment_id: paymentData.id,
62      status: 'processing',
63      initiated_at: new Date().toISOString(),
64    })
65    .eq('reference_id', internal_reference_id);
66
67  return NextResponse.json({
68    success: true,
69    payment_id: paymentData.id,
70    status: paymentData.status,
71  });
72}

1// app/api/payoneer/webhook/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { createClient } from '@supabase/supabase-js';
4
5export async function POST(request: NextRequest) {
6  // Payoneer webhook payload
7  const body = await request.json();
8
9  const { event_type, payment } = body;
10
11  if (!payment?.id) {
12    return NextResponse.json({ received: true });
13  }
14
15  const supabase = createClient(
16    process.env.NEXT_PUBLIC_SUPABASE_URL!,
17    process.env.SUPABASE_SERVICE_ROLE_KEY!
18  );
19
20  let status: string;
21  switch (event_type) {
22    case 'PAYMENT_COMPLETED':
23      status = 'completed';
24      break;
25    case 'PAYMENT_DECLINED':
26      status = 'failed';
27      break;
28    case 'PAYMENT_ON_HOLD':
29      status = 'on_hold';
30      break;
31    default:
32      status = 'processing';
33  }
34
35  await supabase
36    .from('payments')
37    .update({
38      status,
39      payoneer_status: payment.status,
40      completed_at: status === 'completed' ? new Date().toISOString() : null,
41      updated_at: new Date().toISOString(),
42    })
43    .eq('payoneer_payment_id', payment.id);
44
45  return NextResponse.json({ received: true });
46}