Quora Ads

Navigate to quora.com/business/advertising-api in your browser. This page describes the Quora Ads API and includes a link or contact form to apply for partner access. Your application should describe your intended use case (for example, 'building a mobile FlutterFlow analytics dashboard for my marketing team to monitor campaign performance'), the volume of API calls you expect, and your company or app name. Be specific — a vague application takes longer to approve. Once your application is submitted, you will wait for Quora's team to review and respond. Typical timelines range from a few days to a couple of weeks depending on their current review backlog. During this waiting period, you can prepare your Firebase Cloud Function code and your FlutterFlow project structure, but you cannot test any OAuth flows until you have the actual credentials. When approved, Quora will provide you with a `client_id`, `client_secret`, and documentation for the OAuth-2 authorization flow specific to their platform. Read this documentation carefully — the exact base URL for API endpoints, the authorize URL, and the token exchange URL are all in this documentation. Note also your Quora Ads account ID: log in to the Quora Ads Manager, and the account ID appears in the URL (for example, `ads.quora.com/account/ACCOUNT_ID/campaigns`). Copy this value — it is a required parameter on most campaign data endpoints and you will store it as an App State variable in FlutterFlow. This step has no code — it is process-only. Do not move to Step 2 until you have the `client_id`, `client_secret`, and account ID in hand.

This is the most complex step of the integration and the one that separates a secure production build from a prototype with credentials in the client. The Cloud Function has three responsibilities: (1) exchange the OAuth-2 authorization code for an access token and refresh token the first time; (2) automatically refresh the access token before it expires; (3) expose a campaign-metrics endpoint that FlutterFlow can call with just an account ID and date range. For initial token acquisition: the OAuth-2 flow requires a redirect URI registered with Quora. You will complete this one-time authorization step by visiting Quora's authorization URL in your own browser with your `client_id` and the registered redirect URI, then copying the authorization code from the redirect callback. Your Cloud Function then exchanges this code for an access token and refresh token, storing both in Firebase Firestore (encrypted or in Secret Manager) for future use. This manual step only happens once — after that, the Cloud Function uses the stored refresh token to renew access tokens automatically. For ongoing token refresh: add logic in the Cloud Function that checks whether the stored access token is within a threshold of its expiry time (for example, within 5 minutes). If so, call Quora's token refresh endpoint before making the actual API request. Store the new access token back to Firestore. Verify all endpoint URLs — the authorize URL, token URL, and API base URL — against the documentation you received in your partner approval package. The values in the code example below are placeholders that must be replaced with the actual URLs from Quora's partner documentation.

1const functions = require('firebase-functions');
2const admin = require('firebase-admin');
3
4admin.initializeApp();
5
6// Store client credentials as Firebase Secrets
7// firebase functions:secrets:set QUORA_CLIENT_ID
8// firebase functions:secrets:set QUORA_CLIENT_SECRET
9
10// IMPORTANT: Verify these URLs from your Quora partner documentation
11const QUORA_TOKEN_URL = 'https://www.quora.com/oauth2/token'; // VERIFY
12const QUORA_API_BASE = 'https://api.quora.com/ads';            // VERIFY
13
14async function getValidAccessToken() {
15  const tokenDoc = await admin.firestore()
16    .collection('_quora_oauth').doc('tokens').get();
17
18  if (!tokenDoc.exists) {
19    throw new Error('Quora tokens not initialised. Complete the one-time OAuth flow first.');
20  }
21
22  const { access_token, refresh_token, expires_at } = tokenDoc.data();
23  const now = Date.now();
24
25  // Refresh if token expires within 5 minutes
26  if (now >= (expires_at - 5 * 60 * 1000)) {
27    const response = await fetch(QUORA_TOKEN_URL, {
28      method: 'POST',
29      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
30      body: new URLSearchParams({
31        grant_type: 'refresh_token',
32        refresh_token,
33        client_id: process.env.QUORA_CLIENT_ID,
34        client_secret: process.env.QUORA_CLIENT_SECRET,
35      }),
36    });
37    const newTokens = await response.json();
38
39    await admin.firestore().collection('_quora_oauth').doc('tokens').set({
40      access_token: newTokens.access_token,
41      refresh_token: newTokens.refresh_token || refresh_token,
42      expires_at: Date.now() + (newTokens.expires_in * 1000),
43    });
44
45    return newTokens.access_token;
46  }
47
48  return access_token;
49}
50
51exports.quoraAdsProxy = functions
52  .runWith({ secrets: ['QUORA_CLIENT_ID', 'QUORA_CLIENT_SECRET'] })
53  .https.onRequest(async (req, res) => {
54    res.set('Access-Control-Allow-Origin', '*');
55    if (req.method === 'OPTIONS') {
56      res.set('Access-Control-Allow-Methods', 'GET');
57      res.set('Access-Control-Allow-Headers', 'Content-Type');
58      return res.status(204).send('');
59    }
60
61    try {
62      const token = await getValidAccessToken();
63      const accountId = req.query.account_id;
64      const startDate = req.query.start_date;
65      const endDate = req.query.end_date;
66
67      if (!accountId) {
68        return res.status(400).json({ error: 'account_id is required' });
69      }
70
71      // VERIFY: Replace with the correct campaign metrics endpoint from Quora partner docs
72      const apiUrl = `${QUORA_API_BASE}/v1/accounts/${accountId}/campaigns?` +
73        `start_date=${startDate}&end_date=${endDate}`;
74
75      const apiResponse = await fetch(apiUrl, {
76        headers: { Authorization: `Bearer ${token}` },
77      });
78
79      const data = await apiResponse.json();
80      return res.status(apiResponse.ok ? 200 : apiResponse.status).json(data);
81    } catch (err) {
82      console.error('Quora proxy error:', err);
83      return res.status(500).json({ error: err.message });
84    }
85  });

With the Cloud Function deployed and tokens initialised, you are ready to connect FlutterFlow. Click API Calls in the left navigation panel and click + Add → Create API Group. Name the group QuoraAdsProxy. In the Base URL field paste your Cloud Function's HTTPS trigger URL from the Firebase console. Do not add any Authorization header — all credentials are handled inside the Cloud Function. Inside the group, click + Add to create an API Call. Name it GetCampaigns. Set the method to GET. Leave the endpoint path empty. In the Variables tab add three variables: `account_id` (String, default = your Quora account ID), `start_date` (String, default = '2026-01-01' in YYYY-MM-DD format), and `end_date` (String, default = today's date). In the URL Parameters section map each variable to its corresponding query parameter name. Navigate to Response & Test. Set real values for your account ID and a date range, then click Test API Call. When the proxy returns Quora Ads data, the response panel shows the JSON structure. Click Generate JSON Paths and look for the campaign array, campaign names, impression counts, click counts, spend amounts, and any other metrics you want to display. Select and save the JSON Paths you need. If the field names in the actual Quora response differ from what you expected (which is common given the lightly documented API), inspect the raw response JSON and use a JSON path tester to find the correct paths before finalising your bindings. The shape of the response object — whether campaigns are a top-level array or nested under a data key — will only be visible once you have a live response from your own account.

1{
2  "api_group": "QuoraAdsProxy",
3  "base_url": "https://us-central1-YOUR_PROJECT.cloudfunctions.net/quoraAdsProxy",
4  "calls": [
5    {
6      "name": "GetCampaigns",
7      "method": "GET",
8      "variables": [
9        { "name": "account_id", "type": "String", "default": "YOUR_QUORA_ACCOUNT_ID" },
10        { "name": "start_date", "type": "String", "default": "2026-01-01" },
11        { "name": "end_date", "type": "String", "default": "2026-07-10" }
12      ],
13      "url_params": {
14        "account_id": "{{account_id}}",
15        "start_date": "{{start_date}}",
16        "end_date": "{{end_date}}"
17      },
18      "note": "JSON paths depend on the actual Quora API response shape — verify from a live response"
19    }
20  ]
21}

Create a new page in FlutterFlow for the Quora Ads analytics dashboard. At the top of the page add two DatePicker widgets or text fields for the start and end date filter, and a Button labelled 'Refresh' or 'Load'. Store the selected dates in Page State variables. Wire the Button's action to Backend/Database → API Request → QuoraAdsProxy → GetCampaigns, binding the `start_date` and `end_date` variables to the Page State date values. For the campaign summary table, add a DataTable widget to the page. Set its data source to the API Call response array (select the JSON Path that returns the list of campaigns). Map the table columns to the relevant fields: campaign name (text), impressions (integer), clicks (integer), spend (decimal formatted as currency), and CTR (calculated or directly returned). FlutterFlow lets you add conditional formatting on column cells — use it to highlight spend values above a budget threshold in amber or red. For a visual spend breakdown, add a Bar Chart or Line Chart widget below the table. Set the X-axis to campaign names and the Y-axis to spend or impression values from the same API response array. This gives an immediate visual comparison across campaigns for the selected date range. Add a Page State Boolean `isLoading` and wire it to a loading indicator (CircularProgressIndicator) that overlays the table and chart area while the API Call is in flight. Campaign data requests can take 2-5 seconds depending on the date range and number of campaigns — a visible loading state prevents the founder from tapping Refresh repeatedly and making duplicate API calls.

Unlike most integrations where the main error path is a wrong API key, Quora Ads has three failure modes specific to its partner-gated OAuth-2 model that your FlutterFlow app should communicate clearly to any user who encounters them. First, if the one-time OAuth token initialisation has never been completed (the Firestore tokens document does not exist), the Cloud Function returns an error message like 'Quora tokens not initialised'. In your FlutterFlow Action Flow, check the API Call response for a non-200 status and show a specific error screen explaining that an administrator must complete the one-time OAuth setup before the dashboard can be used. This is especially relevant if you are building the app for a team where the developer sets up the backend but a marketing manager uses the dashboard. Second, if the refresh token expires (this can happen if the account is deauthorised or if the refresh token is rotated by Quora's server), the Cloud Function will return a 401. Add this error state to your dashboard: display a message like 'Authentication expired — please contact your administrator to reconnect the Quora Ads account' rather than a generic network error. Third, if the API returns a 429 rate-limit response, disable the Refresh button for a configurable cooldown period (store the last-refreshed timestamp in App State and compare against the current time before allowing another call). Display a message indicating when the user can try again. Since Quora Ads API rate limits are documented in the partner materials rather than public docs, treat the rate limit threshold as something to discover empirically during testing and build an appropriate cooldown accordingly.