> 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.

# Caller ID & CNAM

## Caller ID vs. caller name

The **Caller ID** is the phone number displayed to the called party; **CNAM** is the accompanying text (name or company) that some carriers display alongside it.
CNAM only works on PSTN calls — for SIP-to-SIP calls, the displayed identity comes from the **Caller ID** field on your SIP endpoint.

When a phone call is made, the Caller ID (CLID) is routed to the destination's carrier for delivery.
The Caller Name (CNAM) text data is not sent out by the originating carrier, as they are separate services.\
When the call arrives, the carrier for the destination end of the call will reference the inbound number against its local CNAM database.
At this point, both a CLID number and CNAM text are usually delivered to the recipient's (called party's) phone when it rings through.

## Set CNAM for PSTN numbers

If your number's carrier offers caller ID name (CNAM), you can set the name in your SignalWire Dashboard or with the REST API.

To set the name over the API, call [Request a caller ID name](/docs/apis/rest/caller-id-name/request-caller-id-name):

### Request

POST https\://%7BYour\_Space\_Name%7D.signalwire.com/api/relay/rest/phone\_numbers/\{id}/cnam

```curl
curl -X POST https://{your_space_name}.signalwire.com/api/relay/rest/phone_numbers/id/cnam \
     -H "Content-Type: application/json" \
     -u "<project_id>:<api_token>" \
     -d '{
  "name": "Acme Plumbing"
}'
```

```python
import requests

url = "https://{your_space_name}.signalwire.com/api/relay/rest/phone_numbers/id/cnam"

payload = { "name": "Acme Plumbing" }
headers = {
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<project_id>", "<api_token>"))

print(response.json())
```

```javascript
const url = 'https://{your_space_name}.signalwire.com/api/relay/rest/phone_numbers/id/cnam';
const credentials = btoa("<project_id>:<api_token>");

const options = {
  method: 'POST',
  headers: {
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"name":"Acme Plumbing"}'
};

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"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://{your_space_name}.signalwire.com/api/relay/rest/phone_numbers/id/cnam"

	payload := strings.NewReader("{\n  \"name\": \"Acme Plumbing\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.SetBasicAuth("<project_id>", "<api_token>")
	req.Header.Add("Content-Type", "application/json")

	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/relay/rest/phone_numbers/id/cnam")

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

request = Net::HTTP::Post.new(url)
request.basic_auth("<project_id>", "<api_token>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Acme Plumbing\"\n}"

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.post("https://{your_space_name}.signalwire.com/api/relay/rest/phone_numbers/id/cnam")
  .basicAuth("<project_id>", "<api_token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Acme Plumbing\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://{your_space_name}.signalwire.com/api/relay/rest/phone_numbers/id/cnam', [
  'body' => '{
  "name": "Acme Plumbing"
}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    '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/relay/rest/phone_numbers/id/cnam");
client.Authenticator = new HttpBasicAuthenticator("<project_id>", "<api_token>");
var request = new RestRequest(Method.POST);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Acme Plumbing\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = ["name": "Acme Plumbing"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://{your_space_name}.signalwire.com/api/relay/rest/phone_numbers/id/cnam")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```

A new name, or one previously rejected or failed, is queued for compliance review and returns with a `status` of `pending`.
If the name is already approved for the number, the request returns that approval and re-applies the name without another review.
Poll [Get the caller ID name](/docs/apis/rest/caller-id-name/retrieve-caller-id-name) while a request is `pending` or `in_review`.
After approval, the name appears as `cnam` on the phone number and can be displayed to call recipients.
To remove a name, call [Clear the caller ID name](/docs/apis/rest/caller-id-name/clear-caller-id-name).

### If CNAM isn't available for your number

Not every carrier offers CNAM.
If the API returns `422` and an item in `errors` has the `detail` `Caller ID name isn't available for this number.`, use the support process below.
Other `422` responses indicate a problem with the requested name that you should correct before trying again.
For those numbers, open a support ticket by clicking the **Create a ticket** option, located under the **Support** button in the upper right corner of your [SignalWire Dashboard](https://my.signalwire.com/dashboard).
To display a company or personal name, you must provide either a copy of ID for a personal name, or proof of company through documents with your name listed for the company name.

**In your ticket, include the following:**

* The phone number that needs a CNAM
* Name to display for the CNAM

> **Info**
>
> * CNAM is disallowed on toll-free numbers.
> * Canadian carriers do not read from the National CNAM registry, so CNAM will not display on calls to Canadian numbers.
> * CNAM is limited to **15 characters, including spaces**.
> * Updates take up to **48 hours** to propagate.

> **Note**
>
> If your calls are being labeled as spam or scam, updating CNAM is one part of the fix. See [Resolving spam labels and updating CNAM](/docs/platform/voice/resolving-spam-labels) for the full remediation path.

## Set caller ID for SIP credentials

On a SIP credential, two fields control the displayed identity:

* **Calling another SIP endpoint** — set the **Caller ID** field. This is the only way to display caller ID on SIP-to-SIP calls.
* **Calling a PSTN number** — set the **Send As** field to a purchased or verified number. If unset, the default behavior is to use a random number from your account.

Configure both fields in your [SIP Endpoint settings](https://my.signalwire.com/resources/sips).

The SIP Endpoint settings include **Username**, **Password**, **Caller ID**, and **Send As** fields. Use **Caller ID** for SIP-to-SIP calls and **Send As** for PSTN calls.

To set caller names by extension on SIP-to-SIP calls, configure that within your PBX.
For example, Asterisk uses the **Outbound Caller ID name** option on the dialplan. Check your PBX documentation for details.

## Verified caller ID

A **verified caller ID** is a phone number you already own (such as your mobile or office landline) that has been verified with SignalWire.
Verified numbers are not ported — your original provider continues to service them.
SignalWire does not charge for the number itself, only for usage on the SignalWire network.

> **Warning**
>
> Verified caller ID numbers can **only** be used for placing outbound calls. They cannot receive inbound calls through SignalWire.

To verify a number:

1. In the SignalWire Dashboard, click **Phone Numbers** in the sidebar.
2. Click the **Verified** tab, then click **+ New**.
3. Enter the phone number and click **Call Me**.
4. Enter the verification code you receive via phone call and click **Verify**.

Once verified, the number appears in your verified numbers list and can be used as the outbound caller ID on any SIP credential.
To set it for a specific credential, edit the credential and select the verified number under **Send As**.