RapidoReach
Build a working reward flow

Web offerwall API

Connect a website to the hosted offerwall with a server-generated UID, or evaluate direct inventory APIs for a custom presentation.

Hosted iframe + server-generated UID · Guide reviewed October 15, 2026

RapidoReach public web playground showing sample survey cardsPublic web playground · Sample inventory · Native presentation varies

From install to the first open.

The example below implements the hosted iframe path. Choose it when you want RapidoReach to render the wall. For custom cards, agree API access, authentication and inventory schema before implementing the direct API contract.

1. Install the released package

Keep the App Key on your server. Derive the internal user ID from your authenticated session and return only the signed offerwall URL to the browser.

Package and source reference

2. Configure your app

A server capable of generating the documented UID, a signed-in user, an approved website app and a server callback endpoint. Direct inventory API access has a separate contract; see the API reference before building a custom wall.

Create a publisher app in the dashboard and use its SDK token with a stable, non-personal app user ID. The web UID signing App Key stays on your backend.

Web integration reference

3. Connect your opt-in entry point

Replace the placeholders in your own app. Catch SDK errors in the calling screen, handle unavailable inventory and refresh balances from your server.

Node.js / HTML / integration example
// Node.js backend only. Never bundle this with browser code.
const { createHash } = require('node:crypto');

function offerwallUrl(authenticatedUserId, appId, appKey) {
  const payload = authenticatedUserId + '-' + appId;
  const checksum = createHash('md5')
    .update(payload + '-' + appKey).digest('hex');
  const uid = payload + '-' + checksum;
  return 'https://www.rapidoreach.com/ofw/?userId='
    + encodeURIComponent(uid);
}

// In your authenticated server route, pass the resulting URL
// to your page template. Render it as the iframe src:
// <iframe title="Earn rewards" src="SERVER_GENERATED_URL"
//   style="width:100%;min-height:700px;border:0"></iframe>

Or fetch inventory for your own survey cards

Call from an authenticated backend, handle an empty list and preserve returned survey entry URLs. Use the API callback contract to verify rewards.

Node.js server API / integration example
// Node.js 20+ backend only; keep the app key in server config.
// Resolve user.id from the session and profile fields with consent.
async function fetchSurveys(user, appId, appKey) {
  const response = await fetch('https://www.rapidoreach.com/getallsurveys-api', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-RapidoReach-Api-Key': appKey,
    },
    body: JSON.stringify({
      UserId: user.id, AppId: appId, IpAddress: user.publicIp,
      City: user.city, CountryLanguageCode: user.locale,
    }),
    signal: AbortSignal.timeout(10000),
  });
  const result = await response.json();
  if (result.ErrorCode === 'NOT_FOUND') return [];
  if (!response.ok || result.ErrorCode !== 'SUCCESS') {
    throw new Error('Survey inventory unavailable');
  }
  return (result.Data || []).map(survey => ({
    url: survey.SurveyUrl, // Open unchanged; never use Link.
    reward: survey.Reward, minutes: survey.LOI,
    currency: survey.vc_name,
  }));
}

Review the direct monetization API for the separate custom-wall path. The UID checksum above authenticates the hosted wall; it is not the reward callback verification algorithm.

Request and response reference

Inspect the wall. Try the return flow.

These are screenshots of the public web playground, captured October 15, 2026. They show sample survey cards shared as a visual reference, not screenshots of a Web native build or a guarantee of inventory.

Mobile layout of the public web demo with four sample survey cards
Mobile web demo. Open image to inspect the full capture.
Web reward journeySimulation

This local interaction illustrates presentation states. It does not call the SDK, load live surveys or issue rewards.

Ready to explore

A survey is available in this simulated placement.

Open the public widget playground ↗

The playground previews layout and themes. To validate Web SDK behavior, use the package example and your own development app on a supported device.

Get the Web package / example

Make the first reward traceable.

Set up a test user

Use a development publisher app. In the app’s Test users section, add the raw app user ID exactly as your SDK sends it and enable Test mode for that test user. For web, generate the signed UID from that same raw user ID.

The test survey helps verify the journey. Keep test activity separate from live earnings.

Open the integration testing guide

Verify your server ledger

Configure the app’s server callback and send a Test Callback from the dashboard. Verify the documented hash, attribute the transaction to the correct user and store it once. Repeat the same transaction to check duplicate handling.

Client reward notifications should refresh UI. They should not create a second credit.

Callback verification reference

Web acceptance checklist

  1. Generate a UID on your backend and validate it with the UID Playground.
  2. Check iframe height and navigation at desktop and narrow mobile widths.
  3. Use a test callback to verify attribution; do not credit from browser events.
  4. Test loading, no inventory, offline, invalid credentials and retry. Reopen for the same user and verify attribution stays consistent.
  5. Confirm your backend handles duplicate and invalid callback hashes, then review reversal handling before enabling live traffic.

Find the failing boundary.

UID or checksum is rejected

Use internalUserId-appId-checksum with the lowercase MD5 of internalUserId-appId-appKey. Preserve casing and hyphens, then URL-encode the final UID.

The wrong user receives attribution

Resolve identity from the server’s authenticated session. Never trust a user ID supplied by an arbitrary browser query parameter.

Iframe loads but rewards never arrive

Configure and test the server callback. Browser navigation, postMessage events and iframe close actions are presentation signals, not reward evidence.

The user completed a survey but the balance is unchanged

Trace the same app user ID and transaction through your callback receiver and reward ledger. Check hash verification, duplicate detection and currency conversion. Use redacted diagnostics when contacting support.

Build your web offerwall api pilot.

Create a publisher account, register your app and connect the first test user. Review the reward flow before opening the placement to live users.

Choose another integration path.