Zoho Books

Go to api-console.zoho.com and sign in with your Zoho account. Click '+ Add Client' → select 'Self Client'. Once the self-client is created, copy the Client ID and Client Secret — these go into your Firebase Cloud Function, never into FlutterFlow. Click the 'Generate Code' tab. In the Scope field, enter scopes for Zoho Books specifically: `ZohoBooks.invoices.READ,ZohoBooks.invoices.CREATE,ZohoBooks.customers.READ,ZohoBooks.settings.READ`. The `ZohoBooks.settings.READ` scope is required to call the `/organizations` endpoint. Set the Time Duration to the maximum available (typically 10 minutes) and click 'Create'. Copy the generated grant code immediately — it expires quickly. Exchange this grant code for a refresh token by making a POST to the Zoho token endpoint. For US accounts: `https://accounts.zoho.com/oauth/v2/token`; for EU: `https://accounts.zoho.eu/oauth/v2/token`; for India: `https://accounts.zoho.in/oauth/v2/token`; for Australia: `https://accounts.zoho.com.au/oauth/v2/token`. Post form-encoded body params: `grant_type=authorization_code`, `client_id=[your client id]`, `client_secret=[your client secret]`, `code=[your grant code]`, and `redirect_uri=` (empty). The response contains a `refresh_token` — copy it. This is the long-lived credential that goes into Firebase. Note: if you already have a Zoho self-client from a Zoho CRM integration, you can reuse it — just re-generate a grant code with the ZohoBooks scopes instead of ZohoCRM scopes to get a Books-scoped refresh token.

1// Exchange grant code for refresh token (run once, e.g. in browser console or Postman)
2POST https://accounts.zoho.com/oauth/v2/token
3Content-Type: application/x-www-form-urlencoded
4
5grant_type=authorization_code
6&client_id=YOUR_CLIENT_ID
7&client_secret=YOUR_CLIENT_SECRET
8&code=YOUR_GRANT_CODE
9&redirect_uri=
10

Open your Firebase project → Build → Functions. The Cloud Function stores your Zoho Client ID, Client Secret, and Refresh Token, and returns a fresh access token to FlutterFlow whenever called. Create the function code shown below. In your Firebase CLI, configure the function environment: `firebase functions:config:set zohobooks.client_id="..." zohobooks.client_secret="..." zohobooks.refresh_token="..." zohobooks.region="com"` — use `eu`, `in`, or `com.au` for the region if your account is not US-based. Deploy with `firebase deploy --only functions` and copy the HTTPS trigger URL. The function is nearly identical to the Zoho CRM token function — the only difference is the environment key names. If you have both integrations, you can consolidate them into a single multi-service token function or keep them separate for clarity. CORS headers are included so FlutterFlow web builds can call the function from a browser.

1const functions = require('firebase-functions');
2const axios = require('axios');
3
4exports.getZohoBooksToken = functions.https.onRequest(async (req, res) => {
5  res.set('Access-Control-Allow-Origin', '*');
6  if (req.method === 'OPTIONS') {
7    res.set('Access-Control-Allow-Methods', 'GET');
8    res.set('Access-Control-Allow-Headers', 'Content-Type');
9    return res.status(204).send('');
10  }
11
12  const config = functions.config().zohobooks;
13  const tokenUrl = `https://accounts.zoho.${config.region}/oauth/v2/token`;
14
15  try {
16    const params = new URLSearchParams();
17    params.append('refresh_token', config.refresh_token);
18    params.append('client_id', config.client_id);
19    params.append('client_secret', config.client_secret);
20    params.append('grant_type', 'refresh_token');
21
22    const response = await axios.post(tokenUrl, params);
23    return res.json({
24      access_token: response.data.access_token,
25      expires_in: response.data.expires_in
26    });
27  } catch (err) {
28    console.error('Zoho Books token error:', err.response?.data || err.message);
29    return res.status(500).json({ error: 'Token refresh failed' });
30  }
31});
32

Open FlutterFlow → left nav → API Calls → '+ Add' → 'Create API Group'. Name it 'ZohoBooks'. Set the Base URL to your region's Zoho Books API endpoint: - US: `https://www.zohoapis.com/books/v3` - EU: `https://www.zohoapis.eu/books/v3` - India: `https://www.zohoapis.in/books/v3` - Australia: `https://www.zohoapis.com.au/books/v3` Add shared headers at the group level: - `Authorization`: `Zoho-oauthtoken [accessToken]` — add a Variable named `accessToken` of type String and use it here. The prefix is `Zoho-oauthtoken`, not `Bearer`. - `Content-Type`: `application/json` Now add individual API Calls inside the ZohoBooks group: 1. 'getOrganizations' — Method GET, endpoint `/organizations`. This is the bootstrap call. It does NOT need `organization_id` — it returns the list of your organizations. Parse `$.organizations` and specifically `$.organizations[0].organization_id`. 2. 'getInvoices' — Method GET, endpoint `/invoices?organization_id=[organizationId]&sort_column=date&sort_order=D&per_page=50`. Add a Variable `organizationId` of type String. Parse `$.invoices`. 3. 'getCustomers' — Method GET, endpoint `/contacts?organization_id=[organizationId]&contact_type=customer&per_page=100`. Parse `$.contacts`. 4. 'createInvoice' — Method POST, endpoint `/invoices?organization_id=[organizationId]`. Body as JSON with variables for `customerId`, `lineItemName`, `lineItemPrice`, `lineItemQuantity`. In the Response & Test tab for `getInvoices`, paste a sample Zoho Books invoice list response and click 'Generate JSON Paths' to auto-create paths like `$.invoices[0].invoice_number`, `$.invoices[0].total`, `$.invoices[0].status`.

1{
2  "method": "GET",
3  "endpoint": "/invoices?organization_id=[organizationId]&sort_column=date&sort_order=D&per_page=50",
4  "headers": {
5    "Authorization": "Zoho-oauthtoken [accessToken]",
6    "Content-Type": "application/json"
7  }
8}
9

This is the most critical architectural step: both the access token and the organization ID must be fetched before any other Zoho Books API call can succeed. First, set up App State. Click the puzzle-piece icon in the left nav → App State. Add three String variables: - `zbAccessToken` — stores the 1-hour access token (initial value empty) - `zbOrganizationId` — stores the Zoho Books org ID (initial value empty) - `zbTokenCreatedAt` — stores the timestamp of when the token was fetched (initial value empty, optional but recommended) Create the token-service API Group. Left nav → API Calls → '+ Add' → 'Create API Group'. Name it 'ZohoBooksAuth'. Set Base URL to your Firebase Cloud Function's HTTPS trigger URL. Add API Call: Method GET, name `getToken`, endpoint `/getZohoBooksToken`. Now wire the startup sequence to the initial page's 'On Page Load' trigger: 1. Action 1 — 'Backend/API Call' → `getToken` from ZohoBooksAuth. Map `$.access_token` → App State `zbAccessToken`. 2. Action 2 (chained after Action 1 succeeds) — 'Backend/API Call' → `getOrganizations` from ZohoBooks. Pass `App State → zbAccessToken` as `accessToken`. Map `$.organizations[0].organization_id` → App State `zbOrganizationId`. Chaining these two actions in sequence is essential: the `getOrganizations` call needs a valid token (from Action 1) and must complete before any other page can make Books API calls. Add a loading indicator on the initial page that shows while these two calls complete, then navigate to the main screen. For all subsequent Zoho Books API Calls in your app, pass `App State → zbAccessToken` as `accessToken` and `App State → zbOrganizationId` as `organizationId`.

With the token and organization ID in App State, build the invoice listing UI. On your main page, drag a ListView widget onto the canvas. Select it → Backend Query → API Call → `getInvoices` from ZohoBooks. Under Variables, pass `App State → zbAccessToken` as `accessToken` and `App State → zbOrganizationId` as `organizationId`. Under Response JSON Path, enter `$.invoices`. Inside the ListView, add a Column. Bind Text widgets to: - Invoice number: `$.invoice_number` - Customer name: `$.customer_name` - Total: `$.total` (format as currency using a custom Format function or just display as-is) - Due date: `$.due_date` - Status: `$.status` — add a Container with conditional background color: green for 'paid', orange for 'sent', red for 'overdue' For the invoice detail view, add a new page. On navigation (when the user taps a ListView item), pass the invoice's `$.invoice_id` as a page parameter. Use a `getInvoiceById` API Call: `GET /invoices/[invoiceId]?organization_id=[orgId]`, parse `$.invoice` (singular). Display all line items using a nested Column. Crucially, disable auto-refresh on the ListView. Zoho Books has a 2,500 calls/day free limit and 5,000 on paid plans. Even at 25 invoices per fetch, that is only 100–200 list refreshes per day before you hit the cap. Instead, add a 'pull-to-refresh' gesture that triggers an explicit re-fetch, and cache the result in an App State List<Dynamic> variable between navigations. For the 'mark as paid' action, use a POST to `/invoices/[invoiceId]/payments?organization_id=[orgId]` with a JSON body: `{"invoice_id":"[invoiceId]","amount":[totalDue],"payment_mode":"cash","date":"[today]"}`. After success, refresh the invoice detail from the API to show the updated status. If you're building this for a growing team and want to avoid managing the proxy and rate-limit logic yourself, RapidDev's team builds FlutterFlow accounting integrations regularly — book a free scoping call at rapidevelopers.com/contact.

1{
2  "method": "POST",
3  "endpoint": "/invoices/[invoiceId]/payments?organization_id=[organizationId]",
4  "headers": {
5    "Authorization": "Zoho-oauthtoken [accessToken]",
6    "Content-Type": "application/json"
7  },
8  "body": {
9    "invoice_id": "[invoiceId]",
10    "amount": "[amountPaid]",
11    "payment_mode": "cash",
12    "date": "[paymentDate]"
13  }
14}
15