---
title: 'Voice surveys that get answered: DTMF CSAT and NPS in Kenya'
description: >-
  Build DTMF CSAT and NPS voice surveys in Kenya for about KES 1.50 per answered
  call: post-call and outbound flows, getDigits capture and callback loops.
summary: >-
  Build post-call and outbound DTMF surveys with Sautikit: one question per
  call, a 1-to-5 CSAT or 0-to-9 NPS keypress, about KES 1.50 per answered call,
  and a callback for every low score.
date: 2026-10-06T00:00:00.000Z
updated: 2026-11-10T00:00:00.000Z
type: blog
---


A DTMF voice survey calls the customer, asks one question, and records the key they press: 1 to 5 for CSAT, or 0 to 9 for NPS. On Sautikit an answered survey call of about 30 seconds costs KES 1.50, and a call nobody answers costs nothing.

This guide builds two flows, a post-call survey and an outbound survey call, and covers question design for a keypad, the cost per completed response, and how to turn every low score into a callback.

## Why ask by voice

Most customer surveys in Kenya go out by SMS. An SMS survey assumes the customer reads the message, in the language you wrote it in, and bothers to type a reply. A voice prompt in Swahili and English, answered with one keypress, needs none of that, and it works on any phone. Older, rural and feature-phone customers are the ones text surveys tend to miss, and a survey that never hears from them gives you a skewed score.

A survey call also arrives at the right moment. You are calling your own customer, minutes after you served them, about what just happened.

## Flow one: the post-call survey

This is the contact-centre pattern: when the agent's call ends, the caller goes straight into a one-question rating. With Sautikit's [voice actions](/developers/concepts/voice-actions) it is one response document, because actions run top to bottom. When the dialled agent hangs up and the caller is still on the line, the call continues to the next action:

```js
// Returned from your number's voice_callback_url when a call arrives.
res.json({
  actions: [
    { dial: { number: "+254720000000", timeout: 30 } },
    {
      say: {
        text: "Before you go, one question about the call you just had. Swali moja tu kabla hujaenda.",
      },
    },
    {
      getDigits: {
        numDigits: 1,
        timeout: 10, // seconds
        nested: [
          {
            say: {
              text:
                "On a scale of one to five, five meaning excellent, how satisfied are you " +
                "with the help you received? Bonyeza namba moja hadi tano.",
            },
          },
        ],
      },
    },
    { say: { text: "Asante sana. Kwaheri." } },
    { hangup: {} },
  ],
});
```

> 
> 
> A post-call survey only reaches callers who stay on the line. Train agents to close with "please hold for one quick question" and to hang up first, and use the outbound call below for everyone who dropped off.
> 
> 

When the caller presses a key, Sautikit POSTs to the same `voice_callback_url` that serves your inbound line, with the key in `dtmfDigits`. Note that the call is "in survey" when you return these actions (keyed by the caller's number, for example), so your handler treats the digit as a rating and not as a menu choice.

## Flow two: the outbound survey call

The more reliable pattern is a dedicated survey number that calls the customer after the interaction: a closed ticket, a completed delivery, a resolved dispute. Your system places one call per event:

```js
// Run by your ticketing system when a ticket closes.
async function triggerSurveyCall(ticket) {
  const res = await fetch("https://api.sautikit.com/v1/calls", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.SAUTIKIT_API_KEY}`,
      "Content-Type": "application/json",
      // One survey attempt per ticket, even if the job re-runs.
      "Idempotency-Key": `csat:${ticket.id}`,
    },
    body: JSON.stringify({
      from: process.env.SURVEY_NUMBER, // your dedicated survey number
      to: [ticket.customerPhone], // "+2547..."
      // Comes back on the voice callback as ?clientRequestId=...
      client_request_id: `csat-${ticket.id}`,
    }),
  });
  if (!res.ok) throw new Error(`survey call failed: ${res.status}`);
  return res.json();
}
```

The idempotency key (`csat:` plus the ticket ID) means a retried job or a re-run backfill does not call the same customer twice; see [idempotency keys for voice APIs](/blog/idempotency-keys-voice-api). The `client_request_id` carries the ticket through the call, so the survey handler knows which ticket a rating belongs to.

What the customer hears is set on the number. Point the survey number's `voice_callback_url` at your survey handler with `PUT /v1/numbers/{id}/routing`.

## The survey handler

`getDigits` takes `numDigits`, `timeout` in seconds, `finishOnKey` and a `nested` prompt. It does not take a follow-up URL: when the caller presses a key, Sautikit POSTs to your `voice_callback_url` again with `dtmfDigits` set (see the [getDigits reference](/developers/voice-actions/get-digits)). One handler serves the whole survey:

```js
import express from "express";

const app = express();
app.use(express.urlencoded({ extended: true })); // the voice callback delivers JSON (see below)
app.use(express.json());

const COMPANY = "your bank"; // your company name as you want it spoken

const surveyQuestion = {
  actions: [
    {
      getDigits: {
        numDigits: 1,
        timeout: 10, // seconds
        nested: [
          {
            say: {
              text:
                `Hello, this is ${COMPANY} with one quick question about ` +
                "the service you received today. On a scale of zero to " +
                "nine, where nine means excellent, how likely are you to " +
                "recommend us? Kwa kipimo cha sifuri hadi tisa, tisa " +
                "ikiwa bora kabisa, bonyeza namba kwenye simu yako.",
            },
          },
        ],
      },
    },
    { say: { text: "Hatukupokea jibu. Thank you for your time. Kwaheri." } },
    { hangup: {} },
  ],
};

app.post("/survey", async (req, res) => {
  const digits = req.body.dtmfDigits ?? req.body.digits ?? "";
  const ticketId = String(req.query.clientRequestId || "").replace("csat-", "");

  if (!digits) {
    // The customer answered. Ask the one question.
    return res.json(surveyQuestion);
  }

  // The digits are set. Record the score and branch.
  const score = Number(digits);
  await db.surveyResponses.insert({ ticketId, score, respondedAt: new Date() });

  if (score <= 6) {
    // Low score: flag for a callback from a person.
    await db.callbacks.flag(ticketId, { reason: "low_score", score });
    return res.json({
      actions: [
        {
          say: {
            text:
              "Pole kwa hayo. We want to make this right. A member of our " +
              "team will call you back within one business day. Asante.",
          },
        },
        { hangup: {} },
      ],
    });
  }

  return res.json({
    actions: [
      { say: { text: "Asante sana. Thank you for your feedback. Kwaheri." } },
      { hangup: {} },
    ],
  });
});
```

The question sits in the `nested` block, so it plays while Sautikit is listening for a key. A caller who already knows their answer can press it mid-sentence and skip the rest of the prompt. After ten seconds of silence the thank-you plays and the call ends.

## Question design for a keypad: one question per call

Ask one question. Every extra question loses respondents, and on a phone call nobody can scroll back to check what question three said. One question answered by most of your callers gives you better data than five answered by a few. Pick the number you will act on this quarter and ask only that.

**CSAT fits a keypad as it is.** "One to five" is one keypress.

**NPS needs a small change.** The standard NPS scale is 0 to 10, and "10" is two keypresses, which means multi-digit collection, a finish key and more input errors (our [DTMF reliability guide](/blog/dtmf-detection-reliability) covers why). Use a 0 to 9 scale collected with `numDigits: 1`, with 9 as "extremely likely", and shift the cut-offs down one: 9 is a promoter, 7 and 8 are passive, 0 to 6 are detractors. A 0-to-9 keypad score is not directly comparable to a 0-to-10 score collected another way, so track it as your own trend.

Three rules for the script:

- **Say who you are in the first five seconds.** Customers hang up on a recorded voice that has not introduced itself.
- **Give the scale before the question.** "Where nine means excellent" must come before "how likely", because the caller cannot re-read it.
- **Keep the whole prompt under twenty seconds.** Introduction, scale, question.

Call within minutes of the interaction, while the customer still remembers it, and keep automated calls to daytime hours.

## Language and voice

Write the script the way Kenyan service lines speak: English framing with the action repeated in Swahili ("bonyeza namba moja hadi tano"). Give the top of the scale in both languages ("tisa ikiwa bora kabisa") so the meaning of the number does not depend on which language the customer followed.

For customers who mainly speak another local language, record the prompt with a person and use the `play` action in place of `say`, with the same `getDigits` capture. Use the same voice on every survey call so customers come to recognise it.

## What a completed response costs

Outbound calls are KES 3.00 a minute, billed per second (KES 0.05 a second) after the call is answered. A one-question script runs about 20 seconds of prompt plus a keypress and a short thank-you, about 30 seconds in all, so an answered survey call costs **KES 1.50**. An unanswered call costs nothing.

Here is a worked example. The percentages are assumptions; put in your own once you have run a week of surveys. Suppose 100 tickets close, 60 customers answer the call, and 80% of those press a rating:

| | |
|---|---|
| 60 answered calls × KES 1.50 | KES 90 |
| Completed responses | 48 |
| Cost per completed response | About KES 1.90 |

The survey number is KES 500 a month. A post-call survey costs less still, because it only adds a few seconds to a call that is already connected. Full rates are on the [pricing page](/pricing).

| | Outbound survey call | Post-call survey |
|---|---|---|
| Who it reaches | Everyone whose ticket closed | Callers who stay on the line |
| Works without reading or a smartphone | Yes | Yes |
| What you pay for | Seconds on answered calls only | A few extra seconds on an existing call |
| When the answer arrives | Minutes after the event | On the same call |

## Close the loop: a low score becomes a callback

The handler above flags any score of 6 or below with the ticket ID, and the customer hears a commitment before the call ends: "we will call you back within one business day". Work that callback list every morning. It is where the survey pays for itself.

Two additions for later. For open-ended feedback, follow a low score with the `record` action ("after the tone, tell us what went wrong"); Sautikit posts the recording to the `action` URL you set. To track completion, set an `events_url` on the survey number and compare `call.completed` events with your response table: calls that were answered but got no keypress mean the script is losing people, and unanswered calls mean the timing is wrong.

If you want the callback list to become tickets with an owner, [SautiDesk](https://sautidesk.com) runs calls, SMS, WhatsApp and email for a support team on the same Sautikit numbers.

To send your first survey, [claim a Kenyan number](/numbers) for KES 500 a month, top up by M-Pesa or card, and point the number at the `/survey` handler above.

## Further reading

- [Voice actions reference](/developers/concepts/voice-actions): `say`, `play`, `getDigits`, `dial`, `record` and the rest
- [Stop losing key presses](/blog/dtmf-detection-reliability): DTMF reliability on Kenyan networks
- [Cut failed deliveries in Kenya](/blog/logistics-voice-patterns-kenya): post-delivery surveys for logistics
- [Webhooks reference](/developers/concepts/webhooks): signatures, retries and the `call.completed` event
