Send Missed Call Leads to Google Sheets

Short answer: there are three ways to get missed call leads into Google Sheets:

1. CSV import (free, no code, not real time).
2. Real-time webhook into a Google Apps Script web app that appends from, to, timestamp and call_sid, de-duplicating by call_sid. Add a small relay in front if you also want the signature checked, because Apps Script cannot read request headers.
3. Skip the sheet and send leads to Edesy CRM, which accepts the webhook directly (free plan).

Prefer not to code it? We set it up for you on request.

Get a Missed Call Number

Which Option to Choose

Option 1: CSV Import (No Code)

1. In the missed call portal, filter the log by number and date range.
2. Click Export CSV (up to 1M rows).
3. In Google Sheets: File > Import > Upload, choose "Append to current sheet".

Good for daily lists. Without a webhook, pay as you go charges only the ₹499 monthly number rental (plus GST).

Option 2: Real-Time with Google Apps Script

What the webhook sends

Each missed call produces a JSON POST like this:

{
  "event": "call.missed",
  "timestamp": "2026-10-20T09:42:18Z",
  "data": {
    "call_sid": "a1b2c3...",
    "from": "+9198XXXXXXXX",
    "to": "+9180XXXXXXXX",
    "direction": "inbound",
    "status": "missed",
    "phone_number_id": "5e229f03-...",
    "phone_number_name": "Hoarding MG Road"
  }
}

The body is signed with HMAC-SHA256 using your webhook secret, in the header X-Edesy-Signature: sha256=<hex>. Failed deliveries are retried up to 6 times over about 15 minutes with the same call_sid. Full details are in the missed call docs.

Two Apps Script quirks you must know

• No request headers. A web app's doPost(e) gets the body and query parameters, not headers, so it cannot read X-Edesy-Signature.
• It answers with a redirect. Apps Script web apps reply to a POST with a 302 redirect to script.googleusercontent.com. Edesy's webhook sender refuses redirects in general (a redirect could point at an internal address) but follows this one Apps Script hop, so pointing the webhook straight at the /exec URL shows up as delivered. A shortened or custom-domain link to the script redirects somewhere else first and is not followed, so always paste the /exec URL.

To verify the signature as well, put a tiny relay in front that checks it, forwards the event to Apps Script, and returns 200 to Edesy. A free serverless worker is enough.

Step 1: Create the sheet and script

1. Create a Google Sheet with a tab named Leads and headers in row 1: received_at | occurred_at | from | to | number_name | call_sid
2. Open Extensions > Apps Script and paste:

const SHEET_NAME = 'Leads';
const SHARED_KEY = 'replace-with-a-long-random-string';
 
function doPost(e) {
  if (!e || !e.parameter || e.parameter.key !== SHARED_KEY) {
    return json({ ok: false, error: 'unauthorised' });
  }
 
  let body;
  try {
    body = JSON.parse(e.postData.contents);
  } catch (err) {
    return json({ ok: false, error: 'bad json' });
  }
  if (body.event !== 'call.missed' || !body.data) {
    return json({ ok: true, ignored: true });
  }
 
  const d = body.data;
  const lock = LockService.getScriptLock();
  lock.waitLock(10000);
  try {
    const sheet = SpreadsheetApp.getActive().getSheetByName(SHEET_NAME);
    const seen = sheet.getRange('F:F')
      .createTextFinder(String(d.call_sid))
      .matchEntireCell(true)
      .findNext();
    if (seen) return json({ ok: true, duplicate: true });
 
    sheet.appendRow([
      new Date(),
      body.timestamp || '',
      d.from || '',
      d.to || '',
      d.phone_number_name || '',
      d.call_sid || '',
    ]);
  } finally {
    lock.releaseLock();
  }
  return json({ ok: true });
}
 
function json(obj) {
  return ContentService.createTextOutput(JSON.stringify(obj))
    .setMimeType(ContentService.MimeType.JSON);
}

The lock stops two simultaneous calls writing at once, and the call_sid lookup makes retries and replays safe.

Step 2: Deploy as a web app

1. Click Deploy > New deployment, type Web app.
2. Execute as Me; who has access: Anyone.
3. Authorise, then copy the web app URL (ending in /exec).
4. Your forward URL is <web app URL>?key=<SHARED_KEY>.

If you edit the script later, deploy a new version of the same deployment so the URL stays the same.

Step 3: Add a signature-checking relay

This example runs on any serverless worker that supports the standard Fetch and Web Crypto APIs (for example a free Cloudflare Worker). Set two secrets: EDESY_SECRET (your webhook signing secret) and SHEET_URL (the forward URL from step 2).

export default {
  async fetch(request, env) {
    if (request.method !== 'POST') return new Response('ok');
    const raw = await request.text();
 
    const expected = await sign(env.EDESY_SECRET, raw);
    const got = request.headers.get('X-Edesy-Signature') || '';
    if (!timingSafeEqual(expected, got)) {
      return new Response('bad signature', { status: 401 });
    }
 
    const res = await fetch(env.SHEET_URL, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: raw,
      redirect: 'follow',
    });
    return new Response(res.ok ? 'ok' : 'sheet error', { status: res.ok ? 200 : 502 });
  },
};
 
async function sign(secret, body) {
  const key = await crypto.subtle.importKey(
    'raw', new TextEncoder().encode(secret),
    { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'],
  );
  const mac = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(body));
  const hex = [...new Uint8Array(mac)].map((b) => b.toString(16).padStart(2, '0')).join('');
  return 'sha256=' + hex;
}
 
function timingSafeEqual(a, b) {
  if (a.length !== b.length) return false;
  let diff = 0;
  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
  return diff === 0;
}

The relay follows Apps Script's redirect itself and returns a clean 200 to Edesy, so the delivery log shows success. If the sheet is unreachable it returns 502 and Edesy retries.

Check your signature code against a sample payload with the free webhook signature verifier.

Step 4: Connect it in the missed call portal

1. Open Webhooks and add the relay URL.
2. Subscribe to call.missed and set the signing secret (the same value as EDESY_SECRET).
3. Click Send test event and check the sheet.
4. Dial your missed call number and confirm a real row appears.

The weaker shortcut: secret in the URL only

You can skip the relay and rely only on the ?key= query parameter. It keeps casual traffic out, but the key travels in the URL and may appear in logs, and nothing proves the event came from Edesy. Use it only for low-stakes tests or internal sheets.

Option 3: Use a CRM Instead

Sheets work well for one person and a few hundred leads. They get awkward when several people follow up, when you need status and notes, or when rows run into thousands.

Edesy CRM accepts the missed call webhook directly:

1. Add a Custom webhook lead source in the CRM and copy its URL.
2. Paste it into the missed call portal's webhooks page.
3. After the first event, map data.from to the phone field (a one-time step).

Every missed call then becomes a lead you can assign and track, on the free CRM plan. For Salesforce, Zoho, HubSpot or LeadSquared, we connect it for you, usually within a few days, using our webhook and API. See missed call CRM integration.

Cost

Add 18% GST. A one-time setup fee may apply per number. Above about 3,330 webhook events per number a month, Unlimited is cheaper. See missed call service pricing in India.

Troubleshooting

We Can Set It Up for You

If you would rather not touch code, tell us your sheet and we will set up the integration for your account quickly.

Get a Missed Call Number

Related Reading

• How to set up a missed call campaign
• Missed call docs
• Missed call CRM integration
• Edesy CRM