How to Integrate Replit with Zoho Books

1// One-time token exchange script — run this in your Replit Shell
2// node exchange-token.js
3const axios = require('axios');
4
5async function exchangeCode() {
6  const params = new URLSearchParams({
7    code: 'PASTE_YOUR_AUTHORIZATION_CODE_HERE',
8    client_id: process.env.ZOHO_CLIENT_ID,
9    client_secret: process.env.ZOHO_CLIENT_SECRET,
10    redirect_uri: process.env.ZOHO_REDIRECT_URI,
11    grant_type: 'authorization_code'
12  });
13
14  try {
15    const response = await axios.post(
16      'https://accounts.zoho.com/oauth/v2/token',
17      params.toString(),
18      { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
19    );
20    console.log('Access Token:', response.data.access_token);
21    console.log('Refresh Token:', response.data.refresh_token);
22    console.log('Save these to Replit Secrets as ZOHO_ACCESS_TOKEN and ZOHO_REFRESH_TOKEN');
23  } catch (error) {
24    console.error('Token exchange failed:', error.response?.data || error.message);
25  }
26}
27
28exchangeCode();

1const express = require('express');
2const axios = require('axios');
3
4const app = express();
5app.use(express.json());
6
7const ZOHO_CLIENT_ID = process.env.ZOHO_CLIENT_ID;
8const ZOHO_CLIENT_SECRET = process.env.ZOHO_CLIENT_SECRET;
9const ZOHO_ORG_ID = process.env.ZOHO_ORG_ID;
10const ZOHO_BASE_URL = 'https://www.zohoapis.com/books/v3'; // Change to .eu or .in if needed
11
12// In-memory token store (initialized from Secrets)
13let currentAccessToken = process.env.ZOHO_ACCESS_TOKEN;
14let refreshToken = process.env.ZOHO_REFRESH_TOKEN;
15
16async function refreshAccessToken() {
17  const params = new URLSearchParams({
18    refresh_token: refreshToken,
19    client_id: ZOHO_CLIENT_ID,
20    client_secret: ZOHO_CLIENT_SECRET,
21    grant_type: 'refresh_token'
22  });
23  const response = await axios.post(
24    'https://accounts.zoho.com/oauth/v2/token',
25    params.toString(),
26    { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
27  );
28  currentAccessToken = response.data.access_token;
29  console.log('Zoho access token refreshed successfully');
30  return currentAccessToken;
31}
32
33// Create axios client with auto-refresh interceptor
34const zohoClient = axios.create({ baseURL: ZOHO_BASE_URL, timeout: 15000 });
35
36zohoClient.interceptors.request.use(config => {
37  config.headers['Authorization'] = `Zoho-oauthtoken ${currentAccessToken}`;
38  config.params = { ...config.params, organization_id: ZOHO_ORG_ID };
39  return config;
40});
41
42zohoClient.interceptors.response.use(
43  response => response,
44  async error => {
45    if (error.response?.status === 401 && !error.config._retried) {
46      error.config._retried = true;
47      await refreshAccessToken();
48      error.config.headers['Authorization'] = `Zoho-oauthtoken ${currentAccessToken}`;
49      return zohoClient.request(error.config);
50    }
51    return Promise.reject(error);
52  }
53);
54
55// List invoices
56app.get('/api/invoices', async (req, res) => {
57  const { status, page = 1 } = req.query;
58  try {
59    const params = { page };
60    if (status) params.status = status;
61    const response = await zohoClient.get('/invoices', { params });
62    res.json({
63      invoices: response.data.invoices,
64      page_context: response.data.page_context
65    });
66  } catch (error) {
67    console.error('Zoho API error:', error.response?.data || error.message);
68    res.status(500).json({ error: 'Failed to fetch invoices' });
69  }
70});
71
72// Create invoice
73app.post('/api/invoices', async (req, res) => {
74  const { customer_id, line_items, due_date, reference_number } = req.body;
75  if (!customer_id || !line_items || line_items.length === 0) {
76    return res.status(400).json({ error: 'customer_id and line_items are required' });
77  }
78  try {
79    const response = await zohoClient.post('/invoices', {
80      customer_id,
81      line_items,
82      due_date,
83      reference_number
84    });
85    res.json({ invoice: response.data.invoice });
86  } catch (error) {
87    console.error('Zoho API error:', error.response?.data || error.message);
88    res.status(500).json({ error: 'Failed to create invoice' });
89  }
90});
91
92// Get contacts (customers)
93app.get('/api/contacts', async (req, res) => {
94  const { search_text, contact_type = 'customer' } = req.query;
95  try {
96    const params = { contact_type };
97    if (search_text) params.search_text = search_text;
98    const response = await zohoClient.get('/contacts', { params });
99    res.json({ contacts: response.data.contacts });
100  } catch (error) {
101    console.error('Zoho API error:', error.response?.data || error.message);
102    res.status(500).json({ error: 'Failed to fetch contacts' });
103  }
104});
105
106app.listen(3000, '0.0.0.0', () => console.log('Zoho Books server running on port 3000'));

1import os
2import requests
3from flask import Flask, jsonify, request as flask_request
4
5app = Flask(__name__)
6
7class ZohoBooksClient:
8    def __init__(self):
9        self.client_id = os.environ['ZOHO_CLIENT_ID']
10        self.client_secret = os.environ['ZOHO_CLIENT_SECRET']
11        self.refresh_token = os.environ['ZOHO_REFRESH_TOKEN']
12        self.org_id = os.environ['ZOHO_ORG_ID']
13        self.access_token = os.environ['ZOHO_ACCESS_TOKEN']
14        self.base_url = 'https://www.zohoapis.com/books/v3'  # Change to .eu or .in if needed
15
16    def _headers(self):
17        return {'Authorization': f'Zoho-oauthtoken {self.access_token}'}
18
19    def _params(self, extra=None):
20        p = {'organization_id': self.org_id}
21        if extra:
22            p.update(extra)
23        return p
24
25    def refresh_access_token(self):
26        resp = requests.post('https://accounts.zoho.com/oauth/v2/token', data={
27            'refresh_token': self.refresh_token,
28            'client_id': self.client_id,
29            'client_secret': self.client_secret,
30            'grant_type': 'refresh_token'
31        })
32        resp.raise_for_status()
33        self.access_token = resp.json()['access_token']
34        print('Zoho access token refreshed')
35
36    def request(self, method, path, **kwargs):
37        kwargs.setdefault('params', {})
38        kwargs['params'].update({'organization_id': self.org_id})
39        response = requests.request(
40            method, f'{self.base_url}{path}',
41            headers=self._headers(), timeout=15, **kwargs
42        )
43        if response.status_code == 401:
44            self.refresh_access_token()
45            response = requests.request(
46                method, f'{self.base_url}{path}',
47                headers=self._headers(), timeout=15, **kwargs
48            )
49        response.raise_for_status()
50        return response.json()
51
52zoho = ZohoBooksClient()
53
54@app.route('/api/invoices')
55def list_invoices():
56    try:
57        params = {'status': flask_request.args.get('status', 'sent')}
58        data = zoho.request('GET', '/invoices', params=params)
59        return jsonify({'invoices': data.get('invoices', [])})
60    except Exception as e:
61        return jsonify({'error': str(e)}), 500
62
63@app.route('/api/invoices', methods=['POST'])
64def create_invoice():
65    body = flask_request.json
66    if not body.get('customer_id') or not body.get('line_items'):
67        return jsonify({'error': 'customer_id and line_items are required'}), 400
68    try:
69        data = zoho.request('POST', '/invoices', json=body)
70        return jsonify({'invoice': data.get('invoice')})
71    except Exception as e:
72        return jsonify({'error': str(e)}), 500
73
74@app.route('/api/contacts/find-or-create', methods=['POST'])
75def find_or_create_contact():
76    body = flask_request.json
77    email = body.get('email')
78    if not email:
79        return jsonify({'error': 'email is required'}), 400
80    try:
81        # Search for existing contact
82        search = zoho.request('GET', '/contacts', params={'email': email})
83        contacts = search.get('contacts', [])
84        if contacts:
85            return jsonify({'contact': contacts[0], 'created': False})
86        # Create new contact
87        new_contact = zoho.request('POST', '/contacts', json={
88            'contact_name': body.get('name', email),
89            'email': email,
90            'contact_type': 'customer'
91        })
92        return jsonify({'contact': new_contact.get('contact'), 'created': True})
93    except Exception as e:
94        return jsonify({'error': str(e)}), 500
95
96if __name__ == '__main__':
97    app.run(host='0.0.0.0', port=3000)

1// Complete invoice creation with line items
2app.post('/api/invoices/from-order', async (req, res) => {
3  const { customerEmail, customerName, items, currency = 'USD', notes = '' } = req.body;
4
5  if (!customerEmail || !items || items.length === 0) {
6    return res.status(400).json({ error: 'customerEmail and items are required' });
7  }
8
9  try {
10    // Step 1: Find or create customer contact
11    const contactsRes = await zohoClient.get('/contacts', {
12      params: { email: customerEmail, contact_type: 'customer' }
13    });
14
15    let customerId;
16    if (contactsRes.data.contacts?.length > 0) {
17      customerId = contactsRes.data.contacts[0].contact_id;
18    } else {
19      const newContact = await zohoClient.post('/contacts', {
20        contact_name: customerName || customerEmail,
21        email: customerEmail,
22        contact_type: 'customer',
23        currency_code: currency
24      });
25      customerId = newContact.data.contact.contact_id;
26    }
27
28    // Step 2: Build line items
29    const lineItems = items.map(item => ({
30      name: item.name,
31      description: item.description || '',
32      rate: item.price,
33      quantity: item.quantity || 1,
34      unit: item.unit || 'qty'
35    }));
36
37    // Step 3: Create invoice
38    const invoiceResponse = await zohoClient.post('/invoices', {
39      customer_id: customerId,
40      currency_code: currency,
41      line_items: lineItems,
42      notes: notes,
43      payment_terms: 30,  // Net 30 days
44      payment_terms_label: 'Net 30'
45    });
46
47    const invoice = invoiceResponse.data.invoice;
48    res.json({
49      success: true,
50      invoice_id: invoice.invoice_id,
51      invoice_number: invoice.invoice_number,
52      total: invoice.total,
53      due_date: invoice.due_date,
54      status: invoice.status
55    });
56  } catch (error) {
57    console.error('Invoice creation error:', error.response?.data || error.message);
58    res.status(500).json({ error: 'Failed to create invoice', details: error.response?.data });
59  }
60});