Kajabi

The foundation of this integration is the webhook pipeline. In your Kajabi admin panel, navigate to the developer or integrations settings and find the Webhooks section. Create a new webhook and select the events you care about: at minimum `offer.purchased`, `member.granted`, and `member.revoked`. Kajabi provides a webhook signing secret that allows your Cloud Function to verify that incoming requests are genuinely from Kajabi — copy this secret immediately and store it in Firebase Functions config: `firebase functions:config:set kajabi.webhook_secret='YOUR_WEBHOOK_SECRET'`. Deploy a Firebase Cloud Function called `kajabiWebhook` as an HTTP endpoint (onRequest). The function should: parse the raw request body, verify the Kajabi webhook signature using the signing secret (check Kajabi's documentation for the exact HMAC verification method they use), then extract the member email and offer/product details from the event payload. Based on the event type, write to Firestore: for `member.granted` or `offer.purchased`, set `hasAccess: true` on the Firestore document keyed by the member's email. For `member.revoked`, set `hasAccess: false`. Because Kajabi emails are the key, make sure your FlutterFlow Firebase Auth also uses email-based login — this is the bridge between systems. Note: the exact webhook event names, payload structure, and signature verification method depend on your Kajabi plan and version. Consult Kajabi's current developer documentation for precise details — do not rely solely on this tutorial for payload field names.

1// Firebase Cloud Function: functions/index.js
2const functions = require('firebase-functions');
3const admin = require('firebase-admin');
4const crypto = require('crypto');
5const cors = require('cors')({ origin: true });
6admin.initializeApp();
7
8exports.kajabiWebhook = functions.https.onRequest(async (req, res) => {
9  // Verify Kajabi webhook signature
10  // Note: verify the exact header name and HMAC method in Kajabi's docs
11  const webhookSecret = functions.config().kajabi.webhook_secret;
12  const signature = req.headers['x-kajabi-signature'];
13  const body = JSON.stringify(req.body);
14
15  const expectedSig = crypto
16    .createHmac('sha256', webhookSecret)
17    .update(body)
18    .digest('hex');
19
20  if (signature !== expectedSig) {
21    return res.status(401).json({ error: 'Invalid signature' });
22  }
23
24  const { event, data } = req.body;
25  const memberEmail = data?.member?.email || data?.email;
26
27  if (!memberEmail) {
28    return res.status(400).json({ error: 'No member email in payload' });
29  }
30
31  const db = admin.firestore();
32  const memberRef = db.collection('kajabi_members').doc(memberEmail);
33
34  if (event === 'member.granted' || event === 'offer.purchased') {
35    await memberRef.set(
36      { hasAccess: true, offerId: data?.offer?.id, updatedAt: Date.now() },
37      { merge: true }
38    );
39  } else if (event === 'member.revoked') {
40    await memberRef.set(
41      { hasAccess: false, updatedAt: Date.now() },
42      { merge: true }
43    );
44  }
45
46  return res.json({ received: true });
47});
48

In addition to webhooks, Kajabi provides a direct REST API for reading product and offer data. Navigate to your Kajabi admin settings and find the API section — look for API Keys or Access Tokens in the developer or integrations area. Generate an API token. Store this token in Firebase Functions config: `firebase functions:config:set kajabi.api_token='YOUR_API_TOKEN'`. Extend your Cloud Function (or create a new one) to also proxy Kajabi API requests for product catalog data. The Cloud Function accepts a path parameter from FlutterFlow, injects the Kajabi API token as an Authorization header, and returns the response. Because Kajabi's public API surface is limited and the specific endpoints available depend on your plan and Kajabi's current API version, verify each endpoint in Kajabi's developer documentation before building against it. Common endpoints may include product listings and offer details, but do not assume availability. Add CORS headers to all Cloud Function responses so they work in FlutterFlow's web preview as well as on native devices.

1// Add to index.js: Kajabi API proxy
2exports.kajabiApiProxy = functions.https.onRequest((req, res) => {
3  cors(req, res, async () => {
4    const apiToken = functions.config().kajabi.api_token;
5    // Verify the exact Kajabi API base URL and auth format in Kajabi's docs
6    const { path } = req.query;
7
8    if (!path) {
9      return res.status(400).json({ error: 'Missing path parameter' });
10    }
11
12    try {
13      const response = await axios.get(
14        `https://kajabi.com/api/v1/${path}`, // Verify this base URL in Kajabi docs
15        {
16          headers: {
17            Authorization: `Bearer ${apiToken}`,
18            'Content-Type': 'application/json',
19          },
20        }
21      );
22      return res.json(response.data);
23    } catch (err) {
24      const status = err.response ? err.response.status : 500;
25      return res.status(status).json({ error: err.message });
26    }
27  });
28});
29

In FlutterFlow, click API Calls in the left nav → + Add → Create API Group. Name it 'Kajabi'. Set the Base URL to your `kajabiApiProxy` Cloud Function's HTTPS URL. Add a group-level variable `path` of type String. Create the following API Calls inside the group: - 'GetProducts': Method GET, no additional endpoint, query param `path` = `products`. This returns the list of Kajabi products/courses your account has. - 'GetOffers': Method GET, query param `path` = `offers`. Returns available offers with pricing. In the Response & Test tab for each call, run a test (after your Cloud Function is deployed) and generate JSON Paths from the real Kajabi response. The exact JSON structure varies by Kajabi API version — generate paths from actual data rather than guessing field names. In FlutterFlow's left nav, also configure a Firestore collection listener. The `kajabi_members` Firestore collection (written by your webhook function) will serve as the primary data source for membership gating — FlutterFlow's native Firestore integration reads this far more efficiently than an API call on every page load.

The core of the FlutterFlow app experience is showing different content to members versus non-members. With Firebase Auth set up for email/password login, you can look up the logged-in user's email in the `kajabi_members` Firestore collection to check their `hasAccess` field. In FlutterFlow, create a Firestore query on the page or widget level: query the `kajabi_members` collection where the document ID equals the logged-in user's email address. Bind the `hasAccess` field to a page state boolean variable `isMember`. Use conditional visibility on your widgets: - Show the premium content section only when `isMember == true`. - Show a 'Join Kajabi' or 'Enroll Now' button only when `isMember == false`. This button uses a Launch URL action that deep-links to your Kajabi offer checkout page or sales page: `https://your-school.kajabi.com/offers/YOUR_OFFER_SLUG`. For the deep-link to the actual course content on Kajabi, add a 'Continue Learning' button that opens `https://your-school.kajabi.com/products/YOUR_PRODUCT_SLUG` in a browser. The actual course player is hosted on Kajabi — your FlutterFlow app is the membership portal and content gateway, not the course delivery system itself.

There is an important edge case in the webhook-sync architecture: a member might purchase an offer on Kajabi, open the FlutterFlow app within seconds, and find their access not yet granted because the webhook has not been processed yet. Handle this gracefully. The solution is a two-layer check. First, FlutterFlow reads the Firestore `kajabi_members` document (fast, real-time). If `hasAccess` is false but the user believes they are a member, add a 'Refresh Access' button. This button calls a Cloud Function that queries the Kajabi API directly for that user's current offer access status (if the Kajabi API supports it for your plan) and updates Firestore immediately — acting as an on-demand sync that bridges the webhook delay. For Firebase Auth integration, use email/password login in FlutterFlow so the logged-in email can be matched to the Kajabi member record. Alternatively, configure Google sign-in if your Kajabi members commonly use Gmail. When a new user signs up in the FlutterFlow app with an email that exists in `kajabi_members` (because they already purchased on Kajabi), the gating check will work immediately. When a new user signs up before purchasing, they see non-member content until a Kajabi purchase webhook arrives. Store Kajabi API tokens and webhook secrets exclusively in Firebase Functions config. If you'd rather have RapidDev set up this webhook-sync architecture for you, book a free scoping call at rapidevelopers.com/contact — the team builds FlutterFlow integrations like this every week.