# Structured Data Extraction from Phone Calls

> How to reliably pull names, phone numbers and reasons out of phone calls. Required fields, validation, question order, caller ID, read-back and consuming results.

Published: 2026-10-24
Source: https://voicast.jp/en/blog/structured-extraction-from-calls

## Key points

- To extract structured data from a phone call, make only the fields you truly need required, and give each one a key, a spoken label and a type (free text or phone number).
- Ask for one field at a time, but accept anything the caller volunteers up front and only ask for what's missing. Read everything back before finishing.
- Validate the extracted fields again on the receiving side before writing them to your systems. Normalize phone numbers to digits and check their length.

Reliable extraction from phone calls comes down to four habits: **keep required fields to a minimum, define a format for each field, ask one thing at a time, and read everything back before you finish**. LLMs are good at picking details out of free-flowing conversation, but speech recognition makes mistakes, so validation and confirmation have to be part of the flow. And whatever the agent hands you, validate it again before it goes into your booking system or CRM.

## Deciding which fields to collect

Start from **what someone will do after the conversation**. A callback needs a name and number. A booking needs a date and time. Routing needs the reason for calling. Making nice-to-have fields required lengthens every call and increases hang-ups.

Example setups by use case:

| Use case | Required | Optional |
|---|---|---|
| Dental booking | Name, phone, reason | Preferred time, new or returning patient |
| Restaurant booking | Name, phone, date and time, party size | Seating preference, allergies |
| Property viewing | Name, phone, property | Preferred time |
| B2B support | Company, name, phone, issue | Account number |
| Auto repair booking | Name, phone, car model | Preferred date, work needed |

Give each field two names: a **key** your code uses (`name`, `phone`) and a **label** the agent speaks ("your name", "a good number to call you back"). That way you can reword the conversation without touching your integration, and vice versa.

## Types and validation

Define a checkable **format** for each field:

| Field | Format | Check |
|---|---|---|
| Phone number | Digits only | Valid length and prefix for your country |
| Date and time | Date + time | Not in the past; within business hours |
| Party size | Integer | At least 1; within capacity |
| Name | Text | Not empty |
| Reason | Short text summary | Not empty |

When a value fails its check, have the agent ask again. A phone number that's a digit short is almost always a mishearing. (For Japanese numbers: they start with 0 and have 10 or 11 digits. We cover Japanese-specific pitfalls in [Japanese speech recognition on phone calls](https://voicast.jp/en/blog/japanese-speech-recognition-tips).)

For open-ended fields like "reason for calling", a **short summary written by the agent** is more useful downstream than a raw transcript of everything the caller said. Keep the full transcript separately; put just the gist in the field.

## Question order

A good default order: **reason → details the reason requires → name → phone number**.

1. Ask the reason first. It determines which other fields you need, and if a quick FAQ answer resolves the call, you don't need a name or number at all.
2. Ask the details that reason requires (date and time, party size, and so on).
3. Finish with name and callback number.

Ask one field per turn, but **don't re-ask what the caller already told you**. If they open with "I'd like a table for four next Tuesday at 7," you already have the date, time and party size. Ask only for the name and number. Marching through a fixed script regardless makes callers feel unheard.

## Caller ID

On phone calls you often know the calling number. Be careful about using it as the callback number without asking:

- Some callers withhold their number.
- Someone may call from a company's main line.
- The caller may prefer a callback on their mobile.

A good pattern: pass the calling number to the agent as context, and have it ask, "Is this the best number to call you back on?" The calling number is also a handy key for looking the caller up in your CRM.

## Read it all back

Once all fields are collected, **read them back together**:

- Read phone numbers in groups ("five five five, two one three, four four seven one").
- Confirm names by how they sound (and spell them out if your use case needs exact spelling).
- Say dates with the weekday ("Tuesday, November 18th, at 7 p.m.").

If the caller says something's wrong, re-ask only that field and read back again. More in [Read-back confirmation](https://voicast.jp/en/blog/confirm-by-reading-back).

## Consuming the results

Validate fields **again on the receiving side** before writing them anywhere. Even if the agent checked formats, your system knows its own rules best (required columns, length limits, allowed values). Don't drop records that fail; flag them for human review.

## Doing this with voicast

In a voicast agent settings, each entry in `fields` has a `key` (lowercase letters, digits and `_`), a `label` the agent uses when asking, `required`, and a `type` of `text` or `phone`. A `phone` field is reduced to digits and checked as a Japanese number (10 or 11 digits starting with 0); if it doesn't fit, the agent asks again. For phone calls, you can pass the calling number with `<Parameter name="from">` in your TwiML.

Results come back in `fields` from `GET /v1/calls/by-provider/{CallSid}`, and also in the `call.ended` webhook.

```ts
const res = await fetch(
  `https://api.voicast.jp/v1/calls/by-provider/${encodeURIComponent(callSid)}`,
  { headers: { Authorization: `Bearer ${process.env.VOICAST_API_KEY}` } },
);
const call = await res.json();

if (call.outcome === 'completed' && call.fields) {
  const { name, phone, purpose } = call.fields;
  const ok = /^0\d{9,10}$/.test(phone ?? '') && !!name?.trim();
  await saveInquiry({ name, phone, purpose, summary: call.summary, needsReview: !ok }); // your code
}
```

For the instructions side of field design, see [How to write prompts for an AI phone receptionist](https://voicast.jp/en/blog/phone-receptionist-prompt).

## FAQ

### How many fields should I collect?

There's no magic number, but make required only what the post-call work truly needs. Every extra field lengthens the call and raises the chance of a hang-up. Make nice-to-haves optional and capture them if the caller mentions them.

### What if the caller gives everything in one sentence?

Instruct the agent to accept anything already provided, ask only for what's missing, and then read everything back together.

### What if the extracted phone number is wrong?

Catch most errors with a length and prefix check, then read the number back in groups. On the receiving side, validate again and route anything that doesn't fit to a person instead of discarding it.
