# Payoneer

- Tool: FlutterFlow
- Difficulty: Advanced
- Time required: 3–5 hours (plus partner onboarding time)
- Last updated: July 2026

## TL;DR

Connect FlutterFlow to Payoneer by routing all API calls through a Firebase Cloud Function or Supabase Edge Function proxy — Payoneer's API is gated behind partner/program approval, and the OAuth client secret must never touch your Flutter client. Once approved, your proxy exchanges credentials for a Bearer token at /v2/oauth2/token and triggers multi-currency payouts at /v4/payments on your behalf.

## What Payoneer Brings to Your FlutterFlow App

Payoneer is built for one specific use case: paying people in other countries. If your FlutterFlow app connects a platform with international freelancers, gig workers, vendors, or affiliates who need to receive money, Payoneer is the specialist tool — it handles multi-currency transfers, local bank deposits, and Payoneer-balance payouts across 200+ countries. Unlike Stripe Payouts (which focuses on US/EU), Payoneer's strength is in markets like Southeast Asia, Eastern Europe, and Latin America where international wire transfers are expensive and slow.

The single most important thing to understand before you write a line of code: Payoneer's payment API is not self-serve. You cannot sign up and start calling /v4/payments with an API key you generate from a dashboard. You must apply for a Payoneer partner program, be approved, and receive program-scoped credentials — a client ID and secret tied to your program ID. This gating process can take days to weeks depending on your business type and region. Cover this expectation with your team before committing to Payoneer as your payout provider.

Once you have program credentials, the integration architecture is straightforward: OAuth 2.0 client-credentials flow generates a Bearer token at /v2/oauth2/token, then your program makes payouts at /v4/payments targeting specific payees. All of this runs in a backend proxy (Firebase Cloud Function or Supabase Edge Function) — FlutterFlow's compiled Flutter client has no server runtime, so the OAuth secret must never appear in your Dart code or API Call headers. Pricing is partner-agreement-based, so check your contract for per-payout fees; verify current rates with your Payoneer account manager.

## Before you start

- An approved Payoneer partner/program account with a program-scoped client ID, client secret, and program ID (contact Payoneer at partners.payoneer.com to apply)
- Sandbox credentials from your Payoneer account manager (separate from production credentials)
- A Firebase project with Cloud Functions enabled (Blaze/pay-as-you-go plan) OR a Supabase project with Edge Functions
- A FlutterFlow project on any paid plan (API Calls are available on all plans, Custom Code may require a higher tier)
- Basic familiarity with deploying a Node.js Cloud Function or Deno Edge Function via the Firebase or Supabase dashboard

## Step-by-step guide

### 1. Apply for Payoneer Partner Program Access and Get Sandbox Credentials

Before you touch FlutterFlow, you need Payoneer partner/program credentials — this is the step most developers skip, and it's the #1 reason integrations stall. Unlike most APIs where you generate a key from a self-serve dashboard, Payoneer's payment API requires you to be an approved partner with a program ID. Without this, every call to /v2/oauth2/token or /v4/payments returns 401 or 403.

To get started: go to partners.payoneer.com or contact your Payoneer account representative and request access to the Payoneer Partner API program. You'll describe your platform's use case (marketplace payouts, freelancer payments, vendor settlements, etc.), your expected transaction volume, and your business details. Payoneer will review your application and, once approved, provision a program-scoped client ID, client secret, and a program ID.

Critically, request sandbox access at the same time. Your sandbox credentials are different from production credentials and point to api.sandbox.payoneer.com — a testing environment where no real money moves. The sandbox has some feature differences from production (some payout flows behave differently, payee account states may differ), so plan to do smoke testing and not assume perfect sandbox-to-production parity.

Store your credentials securely now: client_id, client_secret, and program_id will go into your Cloud Function / Edge Function's environment variables — never in your FlutterFlow project or Dart code. Keep them out of source control too.

**Expected result:** You have a Payoneer partner client ID, client secret, program ID, and sandbox access. You can confirm credentials by calling POST https://api.sandbox.payoneer.com/v2/oauth2/token from a REST client (Postman or curl) and receiving a 200 with an access_token.

### 2. Deploy a Firebase Cloud Function Proxy for OAuth Token Exchange and Payouts

FlutterFlow compiles to Flutter code that runs on the user's device — iOS, Android, or web browser. There is no server layer between your FlutterFlow app and the internet. This means if you add the Payoneer client secret to an API Call header or hardcode it in a Custom Action, it ships inside the compiled app binary where it can be extracted by anyone who reverse-engineers the APK or inspects the app bundle. A compromised program-scoped Payoneer secret means an attacker can send payouts from your program to accounts they control.

The solution is a backend proxy: a small server function that holds the secret, handles the OAuth token exchange, and calls Payoneer's API. In FlutterFlow-friendly terms, the two best options are Firebase Cloud Functions (Node.js) or Supabase Edge Functions (Deno/TypeScript).

For Firebase: open the Firebase console, go to Functions, and create a new function. Copy the Node.js example below. Set the environment variables PAYONEER_CLIENT_ID, PAYONEER_CLIENT_SECRET, and PAYONEER_PROGRAM_ID in Firebase's secret manager (not in the code itself). Deploy with the Firebase CLI or from the console.

The function does two things: (1) it exchanges your client credentials for a Bearer token at /v2/oauth2/token using the client_credentials grant, and (2) it calls /v4/payments to create a payout to a specific payee. Token caching is implemented — the function stores the token in memory and reuses it until it's within 60 seconds of expiry, avoiding unnecessary token calls that waste your rate limit quota.

Once deployed, Firebase will give you a public HTTPS URL for the function (e.g., https://us-central1-your-project.cloudfunctions.net/payoneerPayout). This is the URL you'll use in FlutterFlow. Make sure to add authentication to the function (e.g., require a Firebase Auth token from the calling app) so anonymous internet users can't trigger payouts.

```
// Firebase Cloud Function: functions/index.js
const functions = require('firebase-functions');
const admin = require('firebase-admin');
const axios = require('axios');

admin.initializeApp();

const PAYONEER_TOKEN_URL = 'https://api.sandbox.payoneer.com/v2/oauth2/token'; // swap to api.payoneer.com for live
const PAYONEER_PAYMENTS_URL = 'https://api.sandbox.payoneer.com/v4/payments';
const CLIENT_ID = process.env.PAYONEER_CLIENT_ID;
const CLIENT_SECRET = process.env.PAYONEER_CLIENT_SECRET;
const PROGRAM_ID = process.env.PAYONEER_PROGRAM_ID;

let cachedToken = null;
let tokenExpiry = 0;

async function getAccessToken() {
  if (cachedToken && Date.now() < tokenExpiry - 60000) {
    return cachedToken;
  }
  const params = new URLSearchParams();
  params.append('grant_type', 'client_credentials');
  params.append('client_id', CLIENT_ID);
  params.append('client_secret', CLIENT_SECRET);
  const response = await axios.post(PAYONEER_TOKEN_URL, params);
  cachedToken = response.data.access_token;
  tokenExpiry = Date.now() + response.data.expires_in * 1000;
  return cachedToken;
}

exports.payoneerPayout = functions.https.onRequest(async (req, res) => {
  if (req.method !== 'POST') return res.status(405).send('Method Not Allowed');
  const { payee_id, amount, currency, description } = req.body;
  if (!payee_id || !amount || !currency) {
    return res.status(400).json({ error: 'payee_id, amount, and currency are required' });
  }
  try {
    const token = await getAccessToken();
    const payoutResponse = await axios.post(
      PAYONEER_PAYMENTS_URL,
      { program_id: PROGRAM_ID, payee_id, amount, currency, description: description || 'Platform payout' },
      { headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' } }
    );
    // Optionally write status to Firestore here
    return res.status(200).json(payoutResponse.data);
  } catch (error) {
    const status = error.response?.status || 500;
    return res.status(status).json({ error: error.response?.data || error.message });
  }
});
```

**Expected result:** The Cloud Function deploys successfully. You can test it with a POST request containing {"payee_id": "test_payee", "amount": 100, "currency": "USD"} and receive a 200 JSON response from the Payoneer sandbox.

### 3. Create a FlutterFlow API Group Pointing to Your Proxy

Now that your proxy is live, you'll wire FlutterFlow to it via an API Group — FlutterFlow's visual tool for defining REST API connections. The key here is that your API Group's base URL points to YOUR Firebase/Supabase function, not to api.payoneer.com. The Payoneer credentials never touch FlutterFlow at all.

In FlutterFlow, click API Calls in the left navigation panel. Click the + Add button and select Create API Group. Name it something clear like PayoneerProxy. In the Base URL field, enter your deployed Firebase Function URL — for example, https://us-central1-your-project.cloudfunctions.net. Leave the headers section empty for now (you'll add a Firebase Auth token in the next substep if you've added auth to your function).

With the API Group saved, click + Add again inside the group and select Create API Call. Name it CreatePayout. Set the Method to POST and the Endpoint Path to /payoneerPayout (matching your function name). Click the Variables tab and add three variables: payee_id (String), amount (double), and currency (String). In the Body tab, set the body type to JSON and write the body template:

{"payee_id": "{{payee_id}}", "amount": {{amount}}, "currency": "{{currency}}"}

Note that amount is a number (no quotes), while payee_id and currency are strings (with quotes). This matches what the proxy expects.

Now go to the Response & Test tab. Paste a sample success response from your Payoneer sandbox (the JSON object the proxy returned when you tested it manually). Click Generate JSON Paths — FlutterFlow will automatically detect the response fields. Add JSON Paths for key fields like $.status and $.payment_id that you'll bind to your app's UI. Click Test to fire a real request with sample values — you should see a 200 response and live data appear.

If your Cloud Function requires Firebase Auth headers, add an Authorization header variable to the API Group's header section and use {{auth_token}} as the value; you'll pass the user's Firebase ID token at call time.

```
{
  "method": "POST",
  "endpoint": "/payoneerPayout",
  "body": {
    "payee_id": "{{payee_id}}",
    "amount": {{amount}},
    "currency": "{{currency}}",
    "description": "{{description}}"
  },
  "headers": {
    "Content-Type": "application/json"
  },
  "response_paths": {
    "payment_id": "$.payment_id",
    "status": "$.status",
    "amount_paid": "$.amount",
    "currency": "$.currency"
  }
}
```

**Expected result:** The CreatePayout API Call shows a green check in the Response & Test tab with a real Payoneer sandbox response. JSON Paths are generated for payment_id and status.

### 4. Build the Payout Trigger UI and Bind the API Call to a Button Action

With the API Call defined, you'll now build the FlutterFlow screen where users initiate a payout. The exact design depends on your app — it might be an admin panel button, a 'Request Payout' screen for individual freelancers, or a bulk-payout form. Here's how to wire it up regardless of layout.

Create a new page or add to an existing one. Add the input fields you need: a Text Field for Payee ID (or a Dropdown populated from your Firestore/Supabase payee list), a Number Field for Amount, and a Dropdown or Text Field for Currency (e.g., 'USD', 'EUR', 'GBP'). Add a Button labeled 'Send Payout'.

Select the button and open the Actions panel on the right side. Click + Add Action. Under the Backend / API Requests section, select API Call. Choose your PayoneerProxy group and the CreatePayout call. In the variable binding section, map each API variable to the corresponding page state or widget value: bind payee_id to the payee text field's value, amount to the number field's value, and currency to the dropdown value.

After the API Call action, add a Conditional Action that checks the API response's status field (via the JSON Path you defined): if status equals 'SUCCESS' (or whatever Payoneer's sandbox returns), show a success dialog or navigate to a confirmation page; if the call fails, show an error snackbar with the response message.

For payout status monitoring: since Payoneer processes payouts asynchronously, the initial API response confirms the payout was accepted, not that it completed. Have your Cloud Function write the payout record to Firestore or Supabase after calling Payoneer. Then in FlutterFlow, bind a list widget to a Firestore Collection or Supabase query for that user's payouts, streaming status updates in real time as your backend receives Payoneer webhook notifications and updates the record.

**Expected result:** Tapping 'Send Payout' in the FlutterFlow Run Mode fires the API Call, receives a response from your proxy, and shows a success or error dialog based on the response status.

### 5. Cache Bearer Tokens and Payee Status Lookups to Stay Within Rate Limits

Payoneer's OAuth token endpoint has its own rate limits — calling it on every payout request wastes quota and adds latency. Your Cloud Function (from Step 2) already implements in-memory token caching, but you should also be aware of a few production-hardening steps.

First, verify that the token caching in your function actually persists between invocations. Firebase Cloud Functions in a warm instance reuse the module scope, so the cachedToken and tokenExpiry variables survive between rapid sequential calls. However, when Firebase spins up a new cold instance, those variables reset. For production at scale, consider storing the token in Firestore with an expiry timestamp so all function instances share one token — this is especially important if you expect concurrent payout requests.

Second, payee account status (whether a given payee's Payoneer account is active and verified) changes rarely — maybe once a week at most. But if your app fetches payee status on every screen load, you burn quota quickly. In your Cloud Function, add a Firestore cache: before calling /v2/programs/{program_id}/payees/{payee_id}, check if you have a Firestore document for that payee with a lastChecked timestamp within the past 5–10 minutes. If so, return the cached status. Only hit Payoneer's API if the cache is stale.

In FlutterFlow, schedule payee status refreshes using a Timer Action rather than refreshing on every page open. You can also let users manually trigger a 'Refresh Status' button that calls a separate API Call (your proxy's /getPayeeStatus endpoint) rather than auto-refreshing on navigation.

For payout status polling: Payoneer payouts are asynchronous (a 200 from /v4/payments means 'accepted for processing', not 'completed'). The cleanest approach is to set up a Payoneer webhook in your program settings that calls a Firebase/Supabase function when a payout transitions to PAID, FAILED, or RETURNED — the function updates the Firestore/Supabase record, and the FlutterFlow app reads status from there via a stream, no polling needed.

```
// Firestore-backed token cache (add to Cloud Function for multi-instance safety)
const db = admin.firestore();

async function getAccessTokenCached() {
  const tokenDoc = await db.collection('_cache').doc('payoneer_token').get();
  if (tokenDoc.exists) {
    const data = tokenDoc.data();
    if (data.expiry > Date.now() + 60000) {
      return data.access_token;
    }
  }
  // Fetch new token
  const params = new URLSearchParams();
  params.append('grant_type', 'client_credentials');
  params.append('client_id', CLIENT_ID);
  params.append('client_secret', CLIENT_SECRET);
  const response = await axios.post(PAYONEER_TOKEN_URL, params);
  const newToken = response.data.access_token;
  const expiry = Date.now() + response.data.expires_in * 1000;
  await db.collection('_cache').doc('payoneer_token').set({ access_token: newToken, expiry });
  return newToken;
}
```

**Expected result:** The function reuses Bearer tokens across payout calls rather than hitting /v2/oauth2/token on each request. Payee status lookups return from the Firestore cache for repeat queries within the TTL window.

### 6. Test on the Payoneer Sandbox, Then Flip to Production

Payoneer provides a sandbox environment at api.sandbox.payoneer.com that lets you test payout flows without moving real money. Your sandbox credentials are entirely separate from your production credentials — the same client_id won't work on both hosts. Test thoroughly before switching.

In your Cloud Function's environment variables, set PAYONEER_BASE_URL=https://api.sandbox.payoneer.com during development. When you're ready to go live, change it to https://api.payoneer.com — just this one variable swap flips the entire integration to production (assuming your production client_id and client_secret are also set in separate env vars like PAYONEER_CLIENT_ID_PROD).

Test the following scenarios in sandbox: (1) successful payout to a registered sandbox payee — verify you get a payment_id and a 'PROCESSING' or 'PENDING' status; (2) payout to an invalid/unregistered payee — verify your proxy returns a useful error and the FlutterFlow UI shows an error message; (3) rapid sequential payouts — verify your token cache is working (the /v2/oauth2/token endpoint should only be called once per token lifetime, not once per payout); (4) webhook receipt — send a test webhook from Payoneer's sandbox dashboard to your webhook endpoint and verify your Firestore record updates.

Note that some payout flows behave differently in sandbox than in production — Payoneer's sandbox has limited payee account states and some edge cases (like RETURNED payouts) may not be fully simulatable. Coordinate with your Payoneer account manager to understand what sandbox coverage you have before relying on it to catch every production scenario.

When you're confident, update the environment variables in your Cloud Function from sandbox to production values, redeploy the function, and run a real low-value test payout to an internal account before opening the feature to users. If you'd rather skip the custom proxy architecture entirely and work with a team that builds FlutterFlow integrations like this every week, RapidDev offers a free scoping call at rapidevelopers.com/contact.

**Expected result:** Sandbox payouts succeed end-to-end: the FlutterFlow button triggers a payout, the Cloud Function logs show a 200 from Payoneer sandbox, the Firestore record shows the payout with a status, and the FlutterFlow screen updates accordingly. When switched to production credentials, a real test payout settles correctly.

## Best practices

- Never put the Payoneer OAuth client secret or program-scoped credentials in your FlutterFlow project, Dart custom action, or API Call headers — always proxy through Firebase Cloud Functions or Supabase Edge Functions.
- Apply for Payoneer partner/program access 2–4 weeks before your planned launch date; approval timelines vary and can block your release if left too late.
- Cache the OAuth Bearer token in Firestore with its expiry timestamp so all Cloud Function instances share one token — prevents cold-start races that cause simultaneous token generation and rate limit errors.
- Set the base URL (sandbox vs production) as an environment variable in your Cloud Function, not hardcoded — makes it trivial to flip environments without redeploying code.
- Store each payout record in Firestore or Supabase immediately after calling /v4/payments, including the payment_id and initial status — this gives you an audit trail and makes webhook status updates easy to match back to the original request.
- Use a Payoneer webhook endpoint (Firebase/Supabase function) to receive payout status updates rather than polling — payouts are async, and polling burns rate-limit quota unnecessarily.
- Cache payee account status lookups for 5–10 minutes in Firestore — payee status changes rarely, and per-request lookups add latency and consume your API quota.
- Test a small-value real payout to an internal Payoneer account before opening the feature to users — sandbox behavior doesn't perfectly replicate production, especially around payee verification states.

## Use cases

### Freelancer marketplace that pays international contractors weekly

A FlutterFlow app connects clients with freelancers across multiple countries. At the end of each week, administrators tap a 'Run Payouts' button in the app, which triggers a backend function to batch-pay all approved freelancers via Payoneer's /v4/payments endpoint in their local currencies. Payout status is streamed back into the app from Firestore so admins can see who was paid and who failed.

Prompt example:

```
Build a payout dashboard screen in FlutterFlow that lists pending payees with their amounts and currencies, has a 'Run Payouts' button that calls my proxy endpoint, and shows each payee's payout status updating in real time from a Firestore collection.
```

### Creator platform distributing royalties to global contributors

A content platform pays video creators and writers monthly royalties based on their content performance. The FlutterFlow app shows each creator their earned balance and a 'Request Payout' button. When tapped, the app sends the payout request to the backend, which calls Payoneer /v4/payments. Creators see their payout status change from 'Pending' to 'Processing' to 'Completed' as Payoneer processes the transfer.

Prompt example:

```
Create a 'My Earnings' screen in FlutterFlow with a payout balance widget, a 'Request Payout' action that calls my Payoneer proxy, and a status indicator that reads payout state from Supabase.
```

### Vendor portal for e-commerce marketplace with multi-currency settlement

An e-commerce marketplace built in FlutterFlow allows vendors from different countries to sell products and receive settlements in their local currency. The admin panel uses Payoneer's /v2/programs/{id} endpoint to look up registered payees, verify their account status, and then trigger settlement payouts through /v4/payments. Payee status lookups are cached in Firestore to avoid hitting API rate limits.

Prompt example:

```
Design a vendor settlement page in FlutterFlow that displays registered Payoneer payees fetched from my proxy, shows their account verification status, and lets me trigger individual or bulk payouts with currency selection.
```

## Troubleshooting

### API returns 401 Unauthorized or 403 Forbidden on every request

Cause: Either the partner/program credentials are wrong, the account hasn't been approved yet, or you're using production credentials against the sandbox URL (or vice versa).

Solution: Confirm your client_id and client_secret match the environment you're targeting: sandbox credentials at api.sandbox.payoneer.com, production credentials at api.payoneer.com. Check that your Payoneer partner program status is 'Active' in the partner portal. If you recently rotated credentials, update the environment variables in your Cloud Function and redeploy.

### Token endpoint call succeeds but /v4/payments returns 404 Not Found

Cause: The program_id in the request body doesn't match the program associated with the credentials, or the /v4/payments path is constructed incorrectly.

Solution: Verify the PAYONEER_PROGRAM_ID env var matches the program ID in your Payoneer partner dashboard exactly. Log the full request URL in your Cloud Function (console.log the axios request config) to confirm the endpoint is correctly formed. Also check that your program has Payouts enabled — some programs are provisioned for different API products and may need Payouts activated separately.

### Payout status stays 'PENDING' indefinitely and never updates in the app

Cause: Payoneer payouts are asynchronous — the initial 200 response only confirms the payout was accepted, not completed. If status never advances to PAID, either (a) the webhook isn't configured, (b) the payee's account needs additional verification, or (c) Payoneer sandbox has limited payee state simulation.

Solution: Set up a Payoneer webhook in your program settings pointing to a Firebase/Supabase function that receives payout notifications. In the webhook handler, update the Firestore/Supabase payout record with the new status. If the payee's Payoneer account is unverified, Payoneer will hold the payout — check the payee's account status via GET /v2/programs/{id}/payees/{payee_id} and surface that in the app.

### FlutterFlow API Call test shows 'Connection refused' or 'XMLHttpRequest error' on web

Cause: Either the Cloud Function URL is wrong, the function isn't deployed yet, or there's a CORS issue (the function doesn't return the right CORS headers for browser-origin requests in FlutterFlow's web Run Mode).

Solution: Add CORS headers to your Cloud Function response. For Firebase functions, wrap the handler with the 'cors' npm package or manually set the response headers: res.set('Access-Control-Allow-Origin', '*') and handle OPTIONS preflight requests. For native mobile builds in FlutterFlow, CORS doesn't apply — but in-browser testing (FlutterFlow's Run Mode web preview) enforces it.

```
// Add to Cloud Function before your main logic:
res.set('Access-Control-Allow-Origin', '*');
res.set('Access-Control-Allow-Methods', 'POST, OPTIONS');
res.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
if (req.method === 'OPTIONS') return res.status(204).send('');
```

### Rate limit errors (429) hitting the token endpoint despite caching

Cause: Multiple concurrent Cloud Function cold starts are each minting a new token simultaneously, racing past the cache check before any of them write to the cache.

Solution: Switch from in-memory token caching to Firestore-backed caching (see Step 5) so all function instances share one token. This eliminates the cold-start race condition. You can also add a small retry-with-backoff wrapper around the token call using exponential backoff on 429 responses.

## Frequently asked questions

### Can I use Payoneer's API without being an approved partner?

No. Payoneer's payment API (/v4/payments, /v2/programs) is not publicly self-serve. You must apply for and be approved as a Payoneer partner with a program ID before any API credentials are issued. Individual Payoneer business accounts cannot call the payout API — only approved partners can. Contact partners.payoneer.com or your Payoneer account manager to start the application process.

### Can I call the Payoneer API directly from a FlutterFlow API Call without a backend proxy?

Technically yes for public endpoints, but absolutely not for payment operations. The OAuth client secret needed for /v2/oauth2/token is a server secret — placing it in a FlutterFlow API Call header or Dart custom action embeds it in your compiled app binary where it can be extracted. Anyone with your program secret could trigger payouts from your program to accounts they control. Always use a Firebase Cloud Function or Supabase Edge Function proxy for any call that requires the client secret.

### How long does it take for a Payoneer payout to complete after calling /v4/payments?

It varies by recipient country, payment method (Payoneer balance vs local bank transfer), and verification status. A 200 response from /v4/payments means the payout was accepted for processing, not that it settled. Bank transfers can take 1–5 business days internationally. Set up Payoneer webhooks to receive payout lifecycle notifications (PENDING → PROCESSING → PAID or FAILED) and reflect those in your app rather than assuming the payment completed immediately.

### What currencies does Payoneer support for payouts?

Payoneer supports payouts in many major currencies including USD, EUR, GBP, JPY, CAD, AUD, and a wide range of emerging market currencies. The exact currency support depends on the payee's country and your program configuration. Check your Payoneer partner agreement and the /v2/programs/{id} endpoint response for the currency options available to your specific program.

### Does FlutterFlow work with Payoneer on web builds?

Yes, because all Payoneer API calls go through your Firebase or Supabase backend proxy — the Flutter web app never calls Payoneer directly, so CORS isn't an issue between the app and Payoneer. However, your Cloud Function does need CORS headers set so the browser-origin FlutterFlow app can POST to your function's URL. Add Access-Control-Allow-Origin headers to the function response and handle the OPTIONS preflight request.

---

Source: https://www.rapidevelopers.com/flutterflow-integrations/payoneer
© RapidDev — https://www.rapidevelopers.com/flutterflow-integrations/payoneer