How to Integrate Replit with Airtable

1// airtable.js — Airtable REST API client (no external packages needed)
2const BASE_URL = 'https://api.airtable.com/v0';
3
4function getHeaders() {
5  const token = process.env.AIRTABLE_TOKEN;
6  if (!token) throw new Error('AIRTABLE_TOKEN secret not set');
7  return {
8    'Authorization': `Bearer ${token}`,
9    'Content-Type': 'application/json'
10  };
11}
12
13function tableUrl(tableName) {
14  const baseId = process.env.AIRTABLE_BASE_ID;
15  if (!baseId) throw new Error('AIRTABLE_BASE_ID secret not set');
16  return `${BASE_URL}/${baseId}/${encodeURIComponent(tableName)}`;
17}
18
19// List records (up to 100 per request by default)
20async function listRecords(tableName, options = {}) {
21  const params = new URLSearchParams();
22
23  // Filter using Airtable formula syntax
24  if (options.filterFormula) {
25    params.set('filterByFormula', options.filterFormula);
26  }
27  // Sort records
28  if (options.sortField) {
29    params.set('sort[0][field]', options.sortField);
30    params.set('sort[0][direction]', options.sortDirection || 'asc');
31  }
32  // Limit results
33  if (options.maxRecords) {
34    params.set('maxRecords', options.maxRecords);
35  }
36  // Select specific fields only
37  if (options.fields && options.fields.length > 0) {
38    options.fields.forEach((field, i) => {
39      params.set(`fields[${i}]`, field);
40    });
41  }
42
43  const url = `${tableUrl(tableName)}?${params.toString()}`;
44  const response = await fetch(url, { headers: getHeaders() });
45  if (!response.ok) {
46    throw new Error(`Airtable error ${response.status}: ${await response.text()}`);
47  }
48  const data = await response.json();
49  return data.records; // Array of { id, createdTime, fields: {...} }
50}
51
52// Create a new record
53async function createRecord(tableName, fields) {
54  const response = await fetch(tableUrl(tableName), {
55    method: 'POST',
56    headers: getHeaders(),
57    body: JSON.stringify({ fields })
58  });
59  if (!response.ok) {
60    throw new Error(`Airtable error ${response.status}: ${await response.text()}`);
61  }
62  return response.json(); // Returns { id, createdTime, fields }
63}
64
65// Update a record (partial update — only specified fields)
66async function updateRecord(tableName, recordId, fields) {
67  const response = await fetch(`${tableUrl(tableName)}/${recordId}`, {
68    method: 'PATCH',
69    headers: getHeaders(),
70    body: JSON.stringify({ fields })
71  });
72  if (!response.ok) {
73    throw new Error(`Airtable error ${response.status}: ${await response.text()}`);
74  }
75  return response.json();
76}
77
78// Delete a record
79async function deleteRecord(tableName, recordId) {
80  const response = await fetch(`${tableUrl(tableName)}/${recordId}`, {
81    method: 'DELETE',
82    headers: getHeaders()
83  });
84  if (!response.ok) {
85    throw new Error(`Airtable error ${response.status}: ${await response.text()}`);
86  }
87  return response.json(); // Returns { deleted: true, id: '...' }
88}
89
90module.exports = { listRecords, createRecord, updateRecord, deleteRecord };

1// server.js — Express server with Airtable backend
2const express = require('express');
3const {
4  listRecords, createRecord, updateRecord, deleteRecord
5} = require('./airtable');
6
7const app = express();
8app.use(express.json());
9
10const TABLE = process.env.AIRTABLE_TABLE_NAME || 'Products';
11
12// GET /products — list all products, optional ?category= filter
13app.get('/products', async (req, res) => {
14  try {
15    const options = {
16      sortField: 'Name',
17      sortDirection: 'asc'
18    };
19
20    // Filter by category if provided
21    if (req.query.category) {
22      options.filterFormula = `{Category} = "${req.query.category}"`;
23    }
24
25    // Filter to only in-stock items
26    if (req.query.inStockOnly === 'true') {
27      options.filterFormula = options.filterFormula
28        ? `AND(${options.filterFormula}, {In Stock} = TRUE())`
29        : '{In Stock} = TRUE()';
30    }
31
32    const records = await listRecords(TABLE, options);
33
34    // Flatten the Airtable response format
35    const products = records.map(r => ({
36      id: r.id,
37      name: r.fields['Name'] || '',
38      price: r.fields['Price'] || 0,
39      category: r.fields['Category'] || '',
40      inStock: r.fields['In Stock'] || false
41    }));
42
43    res.json({ products, count: products.length });
44  } catch (err) {
45    console.error(err.message);
46    res.status(500).json({ error: err.message });
47  }
48});
49
50// POST /products — create a new product
51app.post('/products', async (req, res) => {
52  try {
53    const { name, price, category } = req.body;
54    if (!name || price === undefined) {
55      return res.status(400).json({ error: 'name and price are required' });
56    }
57
58    const record = await createRecord(TABLE, {
59      'Name': name,
60      'Price': parseFloat(price),
61      'Category': category || '',
62      'In Stock': true
63    });
64
65    res.status(201).json({ id: record.id, fields: record.fields });
66  } catch (err) {
67    res.status(500).json({ error: err.message });
68  }
69});
70
71// PATCH /products/:id — update a product
72app.patch('/products/:id', async (req, res) => {
73  try {
74    const updates = {};
75    if (req.body.name !== undefined) updates['Name'] = req.body.name;
76    if (req.body.price !== undefined) updates['Price'] = parseFloat(req.body.price);
77    if (req.body.inStock !== undefined) updates['In Stock'] = req.body.inStock;
78
79    const record = await updateRecord(TABLE, req.params.id, updates);
80    res.json({ id: record.id, fields: record.fields });
81  } catch (err) {
82    res.status(500).json({ error: err.message });
83  }
84});
85
86// DELETE /products/:id
87app.delete('/products/:id', async (req, res) => {
88  try {
89    const result = await deleteRecord(TABLE, req.params.id);
90    res.json(result);
91  } catch (err) {
92    res.status(500).json({ error: err.message });
93  }
94});
95
96app.listen(3000, '0.0.0.0', () => {
97  console.log(`Airtable API server running — table: ${TABLE}`);
98});

1# app.py — Python Flask server with Airtable backend
2import os
3import requests
4from flask import Flask, request, jsonify
5from urllib.parse import quote
6
7app = Flask(__name__)
8
9AIRTABLE_BASE = 'https://api.airtable.com/v0'
10TABLE_NAME = os.environ.get('AIRTABLE_TABLE_NAME', 'Contacts')
11
12def get_headers():
13    token = os.environ.get('AIRTABLE_TOKEN')
14    if not token:
15        raise ValueError('AIRTABLE_TOKEN secret not set')
16    return {
17        'Authorization': f'Bearer {token}',
18        'Content-Type': 'application/json'
19    }
20
21def table_url(table_name=None):
22    base_id = os.environ.get('AIRTABLE_BASE_ID')
23    if not base_id:
24        raise ValueError('AIRTABLE_BASE_ID secret not set')
25    name = table_name or TABLE_NAME
26    return f'{AIRTABLE_BASE}/{base_id}/{quote(name)}'
27
28@app.route('/records', methods=['GET'])
29def list_records():
30    """List records with optional filter formula."""
31    params = {}
32    filter_formula = request.args.get('filter')
33    if filter_formula:
34        params['filterByFormula'] = filter_formula
35
36    sort_field = request.args.get('sort')
37    if sort_field:
38        params['sort[0][field]'] = sort_field
39        params['sort[0][direction]'] = request.args.get('direction', 'asc')
40
41    try:
42        response = requests.get(
43            table_url(),
44            headers=get_headers(),
45            params=params
46        )
47        response.raise_for_status()
48        data = response.json()
49        # Flatten to simple list
50        records = [
51            {'id': r['id'], **r['fields']}
52            for r in data.get('records', [])
53        ]
54        return jsonify({'records': records, 'count': len(records)})
55    except Exception as e:
56        return jsonify({'error': str(e)}), 500
57
58@app.route('/records', methods=['POST'])
59def create_record():
60    """Create a new record from JSON body."""
61    fields = request.json
62    if not fields:
63        return jsonify({'error': 'Request body required'}), 400
64    try:
65        response = requests.post(
66            table_url(),
67            headers=get_headers(),
68            json={'fields': fields}
69        )
70        response.raise_for_status()
71        record = response.json()
72        return jsonify({'id': record['id'], 'fields': record['fields']}), 201
73    except Exception as e:
74        return jsonify({'error': str(e)}), 500
75
76@app.route('/records/<record_id>', methods=['PATCH'])
77def update_record(record_id):
78    """Update specific fields of a record."""
79    fields = request.json
80    try:
81        response = requests.patch(
82            f'{table_url()}/{record_id}',
83            headers=get_headers(),
84            json={'fields': fields}
85        )
86        response.raise_for_status()
87        return jsonify(response.json())
88    except Exception as e:
89        return jsonify({'error': str(e)}), 500
90
91if __name__ == '__main__':
92    app.run(host='0.0.0.0', port=3000)