> Fetch clean Markdown by appending `.md` to any page URL under https://signalwire.com/docs or requesting it with the HTTP header `Accept: text/markdown`. The root index at https://signalwire.com/docs/llms.txt lists the available documentation indexes.

# Enable voice on a WhatsApp number

> Turn on calling for a connected WhatsApp business number from the SignalWire Dashboard and confirm it took effect.

A WhatsApp business number starts out able to send and receive messages. Calling is a separate switch
you turn on per number, from your Dashboard.

Connect a business number first. If the number isn't in your Space yet, start with
[Connect a WhatsApp business number](/docs/platform/voice/whatsapp/onboarding).

## Turn on calling

### Open your WhatsApp connection

In your [SignalWire Dashboard](https://my.signalwire.com), open **Integrations** and select your
WhatsApp Business Account under **Connected Integrations**.

### Find the number

Open the **WhatsApp Numbers** tab. Each number shows a status of **Registered**, **Pending**, or
**Unregistered**, and a **SIP Calling** column.

A **Pending** number hasn't finished registering with Meta. Enabling calling registers it as part of
the same step, so the attempt can fail with a Meta error until that setup is complete. Finish the
setup in the Meta Business dashboard, then select **Sync with Meta** to refresh the status before
you try again.

### Enable calling

In the **SIP Calling** column, select **Enable SIP Calling** and confirm. SignalWire registers the
number for calling with Meta on your behalf.

Enabling calling from the API isn't supported. The WhatsApp number endpoints list numbers and
their status; they don't change them.

## Confirm it worked

The **SIP Calling** column shows **Enabled** once the number is ready. To check programmatically,
list your WhatsApp numbers:

### Request

GET https\://%7BYour\_Space\_Name%7D.signalwire.com/api/messaging/whatsapp/numbers

```curl
curl https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers \
     -u "<project_id>:<api_token>"
```

```python
import requests

url = "https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers"

response = requests.get(url, auth=("<project_id>", "<api_token>"))

print(response.json())
```

```javascript
const url = 'https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers';
const credentials = btoa("<project_id>:<api_token>");

const options = {method: 'GET', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers"

	req, _ := http.NewRequest("GET", url, nil)

	req.SetBasicAuth("<project_id>", "<api_token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request.basic_auth("<project_id>", "<api_token>")

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers")
  .basicAuth("<project_id>", "<api_token>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers', [
  'headers' => [
  ],
    'auth' => ['<project_id>', '<api_token>'],
]);

echo $response->getBody();
```

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers");
client.Authenticator = new HttpBasicAuthenticator("<project_id>", "<api_token>");
var request = new RestRequest(Method.GET);

IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<project_id>:<api_token>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://{your_space_name}.signalwire.com/api/messaging/whatsapp/numbers")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

Each number reports two fields:

| Field           | Meaning                                                                                   |
| --------------- | ----------------------------------------------------------------------------------------- |
| `voice_enabled` | Calling is turned on for the number.                                                      |
| `voice_capable` | The number can take calls: `voice_enabled` is true **and** a calling handler is attached. |

`voice_enabled` turns true as soon as this guide's steps succeed. `voice_capable` stays false until
you [attach a Resource to answer the call](/docs/platform/voice/whatsapp/receive-calls).

## If calling doesn't turn on \[#if-calling-doesnt-turn-on]

Two failures account for most attempts:

**"Two-step verification is already enabled for this number in Meta with a different PIN."** The
number has a two-step verification PIN that SignalWire doesn't hold. Reset it in WhatsApp Manager,
then try again.

**"SIP calling was attempted recently. Please wait before trying again."** Each attempt starts a
five-minute cooldown. The button stays disabled until it passes, and its tooltip shows how long is
left.

#### Calling can switch off

SignalWire renews the number's calling registration with Meta before it expires. If Meta refuses a
renewal, `voice_enabled` returns to false and calls stop arriving. Check this field if calls stop
unexpectedly, then enable calling again from the **SIP Calling** column.

## Next steps

#### [Receive WhatsApp calls](/docs/platform/voice/whatsapp/receive-calls)

Attach a Resource to answer inbound calls, and find them in your logs.

#### [List WhatsApp numbers](/docs/apis/rest/whatsapp/list-whatsapp-numbers)

The full response schema, including every voice field.