# VeriRoute Intel — Full Content Reference

> Real-time phone number intelligence API providing CNAM, LRN, carrier lookup,
> spam detection, and ported number verification for the North American Numbering Plan (NANP).
> This file contains the full technical content of VeriRouteIntel.com for AI consumption.

---

## About VeriRoute Intel

VeriRoute Intel is a B2B phone number intelligence platform providing REST and GraphQL APIs for telecom data enrichment. The service is purpose-built for the North American Numbering Plan (NANP) and serves call centers, VoIP providers, CPaaS/UCaaS platforms, fraud prevention teams, compliance officers, and SMS delivery platforms.

**Core capabilities:**
- LRN (Local Routing Number) lookup with porting history
- CNAM (Caller Name) identification
- Spam, robocall, and scam detection with reputation scoring
- Messaging provider / SMS carrier identification
- FCC Traceback database search
- Bulk lookup jobs (up to 1,000 numbers per batch)
- GraphQL API for flexible queries

**Key differentiators:**
- LRN Activation Date (porting date) included free with every LRN lookup — no competitor includes this
- 99.9% accuracy on LRN data with real-time carrier database syncing multiple times daily
- 99.5% spam detection accuracy using FTC complaint data, carrier reports, and ML pattern recognition
- Sub-36ms average response time for single lookups, 200 requests per second throughput
- Pay-as-you-go pricing — no subscriptions, no monthly minimums, no contracts
- 1,000 free lookups to start, no credit card required

---

## Authentication

All API endpoints require an API key passed as a Bearer token in the Authorization header.

```
Authorization: Bearer YOUR_API_KEY
```

API keys are available from the dashboard after account creation. Each key is scoped to a single account and can be rotated at any time.

**Base URL:** `https://verirouteintel.com`

**Phone number format:** E.164 format is recommended (e.g., `15555550123` — digits only, country code first, no `+` prefix). US/Canada numbers with 10 or 11 digits are also accepted.

---

## Trust API (Comprehensive Phone Intelligence)

The Trust API is the recommended single-call endpoint for comprehensive phone intelligence. It combines spam detection, robocall identification, reputation scoring, CNAM, LRN, carrier data, and porting status in one response.

**Endpoint:** `POST /api/v2/trust`
**Legacy endpoint:** `POST /api/v1/trust`

### Request

```json
POST /api/v2/trust
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "phone_number": "15555550123"
}
```

### Response (v2)

```json
{
  "data": {
    "number": "15555550123",
    "is_spam": false,
    "is_robocall": false,
    "is_scam": false,
    "spam_type": "NONE",
    "complaint_count": 0,
    "subjects": [],
    "reputation_score": 92,
    "trust_level": "high",
    "last_updated": "2026-05-18T00:00:00Z"
  },
  "errors": []
}
```

### Response fields (v2)

| Field | Type | Description |
|---|---|---|
| number | string | The queried phone number |
| is_spam | boolean | True if spam signals detected |
| is_robocall | boolean | True if robocall patterns detected |
| is_scam | boolean | True if scam indicators detected |
| spam_type | string | "SPAM", "ROBOCALL", "SCAM", or "NONE" |
| complaint_count | integer | Total complaint count from all sources |
| subjects | array | Complaint subject categories |
| reputation_score | integer | 0–100 trust score; higher = more trustworthy |
| trust_level | string | "high" (≥70), "medium" (40–69), "low" (<40) |
| last_updated | string | ISO 8601 timestamp of last data update |

### Trust level thresholds

- **high** — reputation_score ≥ 70. Number is likely legitimate.
- **medium** — reputation_score 40–69. Some signals, exercise caution.
- **low** — reputation_score < 40. Strong spam/fraud indicators.

### Data sources

The Trust API aggregates data from:
- FTC (Federal Trade Commission) consumer complaint database
- Carrier-reported spam indicators
- Consumer self-reported complaints
- Machine learning pattern recognition trained on confirmed spam campaigns
- Real-time and historical call pattern analysis

**Accuracy:** 99.5%
**Uptime SLA:** 99.9%
**Rate limits:** 50 requests/second (GET), 25 requests/second (POST)

### v1 response (legacy)

The v1 endpoint returns boolean fields without reputation scoring:

```json
{
  "data": {
    "number": "15555550123",
    "is_spam": false,
    "is_robocall": false,
    "is_scam": false,
    "spam_type": "NONE",
    "complaint_count": 0,
    "first_reported": null,
    "last_reported": null,
    "details": null
  },
  "errors": []
}
```

---

## LRN API (Local Routing Number)

The LRN API returns the Local Routing Number for any NANP phone number. LRN data is essential for accurate call routing, porting status verification, and detecting number reassignment.

**Endpoint:** `POST /api/v1/lrn`

### What is an LRN?

When a phone number is ported from one carrier to another, the number retains its original area code and digits but gets assigned a new Local Routing Number (LRN) that points to the receiving carrier's switch. VoIP and telecom carriers use LRNs to route calls correctly regardless of where the number originated.

Without current LRN data, calls to ported numbers may be misrouted, incur incorrect termination charges, or fail entirely.

### Request

```json
POST /api/v1/lrn
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "phone_number": "15555550123",
  "include_enhanced_lrn": true,
  "messaging_lookup": false,
  "lrn_only": false
}
```

### Request parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| phone_number | string | Yes | Phone number in E.164 format |
| include_enhanced_lrn | boolean | No | Add carrier name, carrier type, OCN, state |
| messaging_lookup | boolean | No | Include messaging provider identification |
| lrn_only | boolean | No | Fast mode — return only the LRN, no enrichment |

### Response

```json
{
  "data": {
    "number": "15555550123",
    "lrn": "17325550100",
    "lrn_activated_at": "2019-03-14T00:00:00Z",
    "enhanced_lrn_data": {
      "carrier": "T-Mobile USA",
      "carrier_type": "WRS",
      "ocn": "6529",
      "state": "NJ",
      "is_ported": true,
      "original_carrier": "AT&T Mobility"
    }
  },
  "errors": []
}
```

### Response fields

| Field | Type | Description |
|---|---|---|
| number | string | The queried phone number |
| lrn | string | Local Routing Number for call routing |
| lrn_activated_at | string | ISO 8601 timestamp when LRN was activated (porting date) — **free with every lookup** |
| enhanced_lrn_data.carrier | string | Current carrier name |
| enhanced_lrn_data.carrier_type | string | Carrier type code (e.g., WRS = Wireless) |
| enhanced_lrn_data.ocn | string | Operating Company Number |
| enhanced_lrn_data.state | string | State/province |
| enhanced_lrn_data.is_ported | boolean | True if number has been ported from its original carrier |
| enhanced_lrn_data.original_carrier | string | Original carrier before porting |

### LRN Activation Date (exclusive)

The `lrn_activated_at` field — the date a number was ported — is included free with every LRN lookup at VeriRoute Intel. No other commercial LRN provider includes this data at no additional cost.

**Use cases for LRN Activation Date:**
- TRACED Act and TCPA compliance: detect recently reassigned numbers to avoid calling new subscribers who never consented
- Fraud detection: unusually recent porting activity is a strong fraud signal
- Number reassignment verification: numbers ported within the last 60 days warrant extra caution for outbound marketing

**Accuracy:** 99.9%
**Database sync:** Multiple times daily
**Rate limits:** 200 requests/second (GET), 100 requests/second (POST)

---

## CNAM API (Caller Name)

The CNAM API returns the registered Caller Name for any NANP phone number. CNAM is the name that appears on the recipient's caller ID display.

**Endpoint:** `POST /api/v1/cnam`

### Request

```json
POST /api/v1/cnam
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "phone_number": "15555550123",
  "include_spam": false
}
```

### Request parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| phone_number | string | Yes | Phone number in E.164 format |
| include_spam | boolean | No | Also return spam detection signals |

### Response

```json
{
  "data": {
    "number": "15555550123",
    "cnam": "JOHN SMITH",
    "is_spam": false,
    "is_robocall": false,
    "is_scam": false,
    "spam_type": "NONE"
  },
  "errors": []
}
```

### Response fields

| Field | Type | Description |
|---|---|---|
| number | string | The queried phone number |
| cnam | string | Registered caller name (up to 15 characters, NANP standard) |
| is_spam | boolean | Spam indicator (only if include_spam=true) |
| is_robocall | boolean | Robocall indicator (only if include_spam=true) |
| is_scam | boolean | Scam indicator (only if include_spam=true) |
| spam_type | string | Spam classification (only if include_spam=true) |

### CNAM database coverage

The CNAM database covers all US and Canadian wireline numbers, most wireless numbers registered with carriers, and VoIP numbers with registered caller ID. Some prepaid wireless and unregistered VoIP numbers may return null or empty CNAM.

**Response time:** < 200ms
**Uptime SLA:** 99.9%
**Rate limits:** 100 requests/second (GET), 50 requests/second (POST)

---

## Spam / Reputation API

The Spam API provides targeted spam, robocall, and scam detection with detailed reputation data. Use this when you only need spam signals without the full Trust API payload.

**Endpoints:**
- `GET /api/v1/spam?phone_number=15555550123`
- `POST /api/v1/spam`
- `POST /api/v1/spam/batch` (up to 100 numbers)

### Single lookup (POST)

```json
POST /api/v1/spam
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "phone_number": "15555550123"
}
```

### Batch lookup

```json
POST /api/v1/spam/batch
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "phone_numbers": ["15555550123", "15555550124", "15555550125"]
}
```

Batch requests accept up to 100 phone numbers per call. Duplicate numbers are automatically deduplicated and charged only once. Billing is two-phase: an estimate is provided before processing, and the final charge reflects actual results.

### Spam report submission

Users and API consumers can report spam numbers:

```json
POST /api/v1/spam/report
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "phone_number": "15555550123",
  "report_type": "robocall",
  "details": "Received automated call claiming to be IRS"
}
```

**Valid report_type values:** spam, robocall, scam, telemarketing, fraud, phishing

**Rate limits:** 50 reports per hour, 5 per minute per API key. Each number can be reported once per 24 hours per API key.

### Spam API rate limits

- GET: 5 per minute
- POST: 50 per hour

---

## Messaging Provider API (SMS Carrier Lookup)

The Messaging Provider API identifies the SMS/MMS carrier for any US phone number. This is distinct from voice carrier — due to number porting, a number's SMS carrier can differ from its voice carrier.

**Endpoint:** `POST /api/v1/messaging`

### Why messaging carrier differs from voice carrier

When a number is ported, voice routing follows the LRN to the new carrier. However, SMS routing is managed separately by aggregators and may still route through the original carrier or a dedicated SMS aggregator. A number can receive calls on Verizon while SMS is handled by T-Mobile or an MVNO.

### Request

```json
POST /api/v1/messaging
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

{
  "phone_number": "15555550123"
}
```

### Response

```json
{
  "data": {
    "number": "15555550123",
    "messaging_provider": "T-Mobile USA",
    "provider_type": "wireless",
    "supports_sms": true,
    "supports_mms": true,
    "is_short_code_eligible": true
  },
  "errors": []
}
```

### Use cases

- **A2P SMS compliance:** Identify the correct aggregator path for Application-to-Person messaging
- **SMS delivery optimization:** Route messages through the correct carrier to avoid delivery failures
- **Cost reduction:** Avoid premium termination fees from routing through the wrong carrier
- **10DLC campaign targeting:** Verify carrier eligibility before registering numbers for 10DLC campaigns
- **MVNO identification:** Distinguish MVNOs from underlying network carriers for accurate routing

**Supported carriers:** All major US providers (Verizon, AT&T, T-Mobile) plus 100+ regional carriers and MVNOs, updated in real time.

**Rate limits:** 75 requests/second (GET), 40 requests/second (POST)

---

## Traceback Search API

The Traceback Search API provides access to the FCC's traceback database of confirmed illegal robocall campaigns. This data is used by regulators, carriers, and compliance teams to identify and block known bad actors.

**Base path:** `/api-docs/traceback-search`

**GraphQL endpoint:** `POST /graphql`

The Traceback API supports both REST and GraphQL queries. GraphQL is recommended for flexible field selection and filtering.

### What is FCC traceback?

The FCC's traceback program (administered by USTelecom's Industry Traceback Group, or ITG) investigates illegal robocall campaigns. When a consumer complaint is filed, the ITG traces the call path back through the telecom network to identify the originating carrier. Traceback records are publicly available and contain information about confirmed illegal robocall originators.

### Use cases

- Carrier compliance: identify and block calls originating from known bad actors
- Fraud prevention: cross-reference inbound calls against confirmed traceback subjects
- Regulatory reporting: generate reports of traceback activity for compliance filings
- Due diligence: screen potential customers or partners against traceback history

**Cost:** Traceback search queries do not consume lookup credits.

**Rate limits:** See `/api-docs/traceback-search/rate-limits`

---

## GraphQL API

VeriRoute Intel supports GraphQL queries for flexible data retrieval across all core endpoints.

**Endpoint:** `POST /graphql`
**Authentication:** Same Bearer token as REST endpoints

### Example query

```graphql
query {
  trustLookup(phoneNumber: "15555550123") {
    number
    reputationScore
    trustLevel
    isSpam
    isRobocall
    complaintCount
  }
}
```

### Example response

```json
{
  "data": {
    "trustLookup": {
      "number": "15555550123",
      "reputationScore": 92,
      "trustLevel": "high",
      "isSpam": false,
      "isRobocall": false,
      "complaintCount": 0
    }
  }
}
```

GraphQL queries can retrieve LRN, CNAM, spam, messaging, and trust data in a single request, reducing round trips for clients that need multiple data points.

**Rate limits:** 60 requests/second

---

## Bulk Lookup

The bulk lookup feature allows processing up to 1,000 phone numbers in a single job. Bulk jobs are processed asynchronously and results are downloadable as CSV.

### Supported endpoints for bulk

- LRN
- CNAM
- Spam/Trust
- Messaging Provider

### How it works

1. Upload a CSV or JSON list of phone numbers via the dashboard or API
2. The job is queued and processed asynchronously using background workers
3. Status is available via job tracking endpoint
4. Results are downloaded as CSV when complete

### Bulk performance metrics

- Maximum numbers per job: 1,000
- Average processing time per number: 61ms
- Connection pool size: 200 concurrent connections
- Performance vs. single lookups: approximately 6.5x faster per-number due to connection pooling

---

## Reporting API

The Reporting API provides usage analytics, credit consumption summaries, and lookup history.

**Base path:** `/api-docs/reporting`

### Available reports

- **Usage summary:** Credits consumed by date range, endpoint, and API key
- **Lookup history:** Paginated log of all queries with results
- **Credit balance:** Current available credit balance
- **Job history:** Status and results for bulk lookup jobs

---

## Pricing

VeriRoute Intel uses pay-as-you-go pricing with no monthly minimums, no subscriptions, and no contracts. Credits are purchased in advance and consumed per lookup.

**Starting price:** From $0.0015 per lookup (volume pricing)
**Free tier:** 1,000 free lookups to start — no credit card required
**Volume discounts:** Available for high-volume usage (contact sales)
**Enterprise pricing:** Custom pricing and dedicated support for enterprise accounts

### Credit costs by endpoint

Each successful lookup consumes one credit:
- LRN lookup: 1 credit
- CNAM lookup: 1 credit
- Spam/Trust lookup: 1 credit
- Messaging Provider lookup: 1 credit
- Traceback Search: 0 credits (free)

**LRN Activation Date** is included free with every LRN lookup at no additional credit cost.

### Billing model

- Credits are pre-purchased and never expire
- Failed requests (validation errors, invalid numbers) do not consume credits
- Bulk job billing uses a two-phase model: estimate before processing, final charge after completion
- Duplicate numbers in batch requests are charged only once

---

## Error Handling

All API errors return a JSON response with a structured error object.

### Error response format

```json
{
  "success": false,
  "data": null,
  "error": {
    "code": "ERROR_CODE",
    "message": "Human-readable error description",
    "details": {}
  }
}
```

### Common error codes

| Code | HTTP Status | Description |
|---|---|---|
| INVALID_API_KEY | 401 | API key is missing, invalid, or revoked |
| INSUFFICIENT_CREDITS | 402 | Account has no remaining credits |
| INVALID_PHONE_NUMBER | 422 | Phone number is not a valid NANP number |
| RATE_LIMIT_EXCEEDED | 429 | Request rate limit exceeded for this endpoint |
| INTERNATIONAL_NUMBER | 422 | International numbers are not supported (NANP only) |
| INTERNAL_ERROR | 500 | Server-side error — contact support |

### Phone number validation

VeriRoute Intel only supports NANP (North American Numbering Plan) numbers:
- US numbers (country code +1)
- Canadian numbers (country code +1)
- Numbers must be 10 digits (or 11 digits with the leading 1)
- International numbers return a friendly error response, not a provider error

---

## Code Examples

### Python

```python
import requests

api_key = "YOUR_API_KEY"
base_url = "https://verirouteintel.com"

def trust_lookup(phone_number):
    response = requests.post(
        f"{base_url}/api/v2/trust",
        headers={"Authorization": f"Bearer {api_key}"},
        json={"phone_number": phone_number}
    )
    return response.json()

result = trust_lookup("15555550123")
print(result["data"]["trust_level"])  # "high"
```

### Node.js / TypeScript

```typescript
const axios = require('axios');

const apiKey = 'YOUR_API_KEY';
const baseUrl = 'https://verirouteintel.com';

async function lrnLookup(phoneNumber: string) {
  const response = await axios.post(
    `${baseUrl}/api/v1/lrn`,
    { phone_number: phoneNumber, include_enhanced_lrn: true },
    { headers: { Authorization: `Bearer ${apiKey}` } }
  );
  return response.data;
}

lrnLookup('15555550123').then(result => {
  console.log(result.data.lrn);
  console.log(result.data.enhanced_lrn_data.carrier);
});
```

### cURL

```bash
curl -X POST https://verirouteintel.com/api/v2/trust \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phone_number": "15555550123"}'
```

### PHP

```php
<?php
$apiKey = 'YOUR_API_KEY';
$baseUrl = 'https://verirouteintel.com';

$ch = curl_init("$baseUrl/api/v1/lrn");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['phone_number' => '15555550123']));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer $apiKey",
    'Content-Type: application/json'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = json_decode(curl_exec($ch), true);
curl_close($ch);
echo $response['data']['lrn'];
```

---

## SDKs

**Python SDK:** `pip install verirouteintel` — available on PyPI
**TypeScript/Node.js SDK:** `npm install verirouteintel` — available on npm
**OpenAPI Specification:** Available at `https://verirouteintel.com/static/openapi.yaml`

---

## Use Cases

### Call Centers — CNAM Enrichment

Call centers use CNAM lookup to display the caller's registered name on agent screens before the call is answered. This allows agents to greet callers by name, reducing handle time and improving customer satisfaction scores.

VeriRoute Intel CNAM is used by both inbound and outbound call centers:
- **Inbound:** Display caller name on agent screen at moment of ring
- **Outbound:** Verify that the name registered for a contact matches the number being dialed
- **Compliance:** Cross-check CNAM against DNC (Do Not Call) registry data

Volume discounts are available for call centers processing high call volumes. Pricing starts at per-lookup rates with no monthly minimums.

### VoIP Providers — LRN for Call Routing

VoIP providers must perform LRN dips on every outbound call to route accurately to ported numbers. Without current LRN data, calls to ported numbers incur incorrect termination charges or fail entirely.

VeriRoute Intel's LRN API:
- Returns the current LRN for routing ported calls
- Includes carrier and switch data for optimal least-cost routing
- Provides LRN Activation Date free — useful for detecting number reassignment
- Maintains 99.9% accuracy with multiple daily database syncs

### SMS Platforms — Messaging Provider Identification

SMS aggregators and CPaaS platforms route A2P (Application-to-Person) messages through carrier-specific paths. An incorrect carrier routing can result in message delivery failures, SPAM filtering, or excess costs.

The Messaging Provider API identifies the correct SMS carrier (not just the voice carrier) so platforms can select the optimal delivery path for each number.

### Fraud Prevention — Spam and Reputation Scoring

Fraud prevention teams use reputation scoring to:
- Flag inbound calls from known spam numbers before routing to agents
- Score outbound lists to avoid contacting high-risk numbers
- Detect account creation fraud using spam-associated phone numbers
- Identify newly ported numbers (high-risk signal for SIM swap fraud)

The Trust API's 0–100 reputation score with categorical trust levels (high/medium/low) integrates directly into risk scoring models.

### CRM Systems — Caller Data Enrichment

CRM platforms integrate the CNAM and Trust APIs to enrich contact records:
- Automatically populate caller name from CNAM at record creation
- Flag contacts with poor reputation scores for review
- Detect when a contact's number has been ported to a different carrier

### TCPA / TRACED Act Compliance

The Telephone Consumer Protection Act (TCPA) and the TRACED Act impose restrictions on automated dialing to phone numbers, particularly those that have been reassigned to new subscribers.

VeriRoute Intel's LRN Activation Date is a critical data point for TCPA compliance:
- Numbers ported (activated) after a consent record was created may have been reassigned
- Callers must obtain new consent from the current subscriber before autodialing
- LRN Activation Date provides the porting timestamp needed to compare against consent records

---

## Free Tools

The following tools are available without an API key:

**Phone Lookup Tool** (`/tools/phone-lookup-tool`): Free phone number lookup showing carrier, line type, and caller ID information.

**Line Type Checker** (`/tools/line-type-checker`): Determine whether a number is landline, mobile, or VoIP.

**Carrier Lookup Tool** (`/tools/carrier-lookup-tool`): Identify the carrier for any US phone number.

**Phone Validator** (`/tools/phone-validator`): Validate US phone number format, active status, and carrier.

**SMS Segment Calculator** (`/tools/sms-segment-calculator`): Calculate SMS message segments, character count, encoding (GSM-7 vs UCS-2), and cost impact. Shows exactly where messages split and which characters trigger multi-part encoding.

**Free Lookup Tool** (`/free-lookup-tool`): Try a free phone number lookup with no signup required.

---

## Performance Specifications

| Metric | Value |
|---|---|
| Single lookup average response time | 36ms |
| Single lookup throughput | 200 requests/second |
| Bulk max numbers per job | 1,000 |
| Bulk average time per number | 61ms |
| Connection pool size | 200 |
| Performance vs. serial lookups | 6.5x faster |
| LRN accuracy | 99.9% |
| Spam detection accuracy | 99.5% |
| Uptime SLA | 99.9% |

---

## Frequently Asked Questions

**What is a Local Routing Number (LRN)?**
An LRN is a 10-digit number assigned to a telephone switch. When a phone number is ported from one carrier to another, the LRN is updated to point to the new carrier's switch. Telecom carriers use LRNs to route calls correctly to ported numbers.

**What is CNAM?**
CNAM (Calling Name) is the name associated with a phone number in the national caller ID database. It is the name that appears on the recipient's caller ID display when a call is placed from that number.

**Does VeriRoute Intel support international numbers?**
No. VeriRoute Intel is purpose-built for NANP (North American Numbering Plan) numbers — US and Canada only. Requests for international numbers return a validation error.

**How often is the LRN database updated?**
The LRN database is synced multiple times per day from authoritative sources. This ensures that porting changes made in the morning are reflected in API responses within hours, not days.

**What is the difference between the voice carrier and the messaging carrier?**
Due to number porting and MVNO arrangements, a phone number's SMS carrier can differ from its voice carrier. The Messaging Provider API identifies the correct SMS carrier specifically, not just the voice carrier from the LRN database.

**How is billing handled for batch jobs?**
Batch jobs use a two-phase billing model. Before processing begins, an estimate of credit consumption is provided. After processing completes, the actual credits consumed are deducted. Duplicate phone numbers in a batch are charged only once.

**Does VeriRoute Intel store the phone numbers I look up?**
VeriRoute Intel stores query logs for billing and reporting purposes. Logs include the queried phone number, timestamp, endpoint used, and result. Query logs are accessible via the Reporting API and the dashboard.

**What happens if my API key is compromised?**
API keys can be revoked and regenerated from the dashboard at any time. Old keys are immediately invalidated upon rotation.

**Is there a free trial?**
Yes. New accounts receive 1,000 free lookups with no credit card required. The free tier covers all API endpoints.

---

## Pages and Documentation Links

- **API Overview:** https://verirouteintel.com/api-docs/
- **Trust API:** https://verirouteintel.com/api-docs/trust/
- **LRN API:** https://verirouteintel.com/api-docs/lrn/
- **CNAM API:** https://verirouteintel.com/api-docs/cnam/
- **Spam API:** https://verirouteintel.com/api-docs/spam/
- **Messaging Provider API:** https://verirouteintel.com/api-docs/messaging/
- **Traceback Search API:** https://verirouteintel.com/api-docs/traceback-search
- **Reporting API:** https://verirouteintel.com/api-docs/reporting/
- **Authentication:** https://verirouteintel.com/api-docs/authentication
- **Rate Limits:** https://verirouteintel.com/api-docs/rate-limits
- **Code Examples:** https://verirouteintel.com/api-docs/code-examples
- **Error Reference:** https://verirouteintel.com/api-docs/errors
- **API Changelog:** https://verirouteintel.com/api-docs/changelog
- **Features:** https://verirouteintel.com/features
- **Pricing:** https://verirouteintel.com/pricing
- **Free Lookup Tool:** https://verirouteintel.com/free-lookup-tool
- **Python SDK (PyPI):** https://pypi.org/project/verirouteintel/
- **TypeScript SDK (npm):** https://www.npmjs.com/package/verirouteintel
- **OpenAPI Specification:** https://verirouteintel.com/static/openapi.yaml
- **Contact:** https://verirouteintel.com/contact
- **Terms of Service:** https://verirouteintel.com/terms-and-conditions
- **Privacy Policy:** https://verirouteintel.com/privacy-policy


## Competitive Positioning

VeriRoute Intel vs. alternatives for phone number intelligence:

| Feature                        | VeriRoute Intel    | Twilio Lookup | Telnyx    | Plivo     | Numverify | AbstractAPI |
|--------------------------------|--------------------|:-------------:|:---------:|:---------:|:---------:|:-----------:|
| LRN / porting data             | Yes                | Partial       | Yes       | Partial   | No        | No          |
| Messaging Provider ID          | YES (UNIQUE)       | No            | No        | No        | No        | No          |
| STIR/SHAKEN attestation        | Yes                | No            | Partial   | No        | No        | No          |
| FCC Traceback database         | Yes                | No            | No        | No        | No        | No          |
| Spam / reputation score        | Yes (0–100)        | No            | No        | No        | No        | Partial     |
| CNAM lookup                    | Yes                | Add-on ($)    | Yes       | No        | No        | No          |
| Bulk / batch API               | Yes                | No            | Partial   | No        | No        | No          |
| GraphQL API                    | Yes                | No            | No        | No        | No        | No          |
| LRN price                      | $0.0005            | $0.01         | N/A       | N/A       | N/A       | N/A         |
| Trust (all-in-one) price       | $0.0015            | N/A           | N/A       | N/A       | N/A       | N/A         |
| CNAM price                     | $0.006             | Add-on        | ~$0.004   | N/A       | N/A       | N/A         |
| PAYG, no subscription          | Yes                | Yes           | Yes       | Yes       | Yes       | Yes         |
| US + Canada NANP focus         | Yes                | Global        | Global    | Global    | Global    | Global      |
| LRN Activation Date (porting)  | Yes (free)         | No            | No        | No        | No        | No          |

### Key Differentiators

**1. Only Messaging Provider API on the market**
No other commercial API identifies the SMS aggregator (Twilio, Bandwidth, Sinch, Vonage,
Telnyx, MessageBird) rather than just the underlying network carrier. This is critical for
10DLC compliance, SMS deliverability optimization, and intelligent message routing.

**2. LRN at $0.0005 — 20x cheaper than Twilio Lookup**
Twilio charges $0.01 per carrier lookup. VeriRoute Intel delivers full LRN with porting
status, OCN, and switch CLLI for $0.0005 — with LRN Activation Date included at no extra
cost.

**3. Real-time STIR/SHAKEN attestation included**
The Trust API returns the STIR/SHAKEN attestation level (A/B/C) for every lookup. Twilio
Lookup and most alternatives do not offer this. Enables branded calling verification and
FCC TRACED Act compliance workflows.

**4. FCC Traceback Consortium database via API**
Search actual FCC traceback investigation records programmatically. No other commercial
API exposes this dataset. Enables robocall investigation workflows and carrier compliance
reporting.

**5. Full intelligence in one call at $0.0015**
The Trust API returns spam score + carrier + CNAM + LRN + porting + STIR/SHAKEN in a
single request. Alternatives require separate API calls (and separate charges) for each
data element.

**6. Bulk API with porting date**
LRN bulk endpoint supports async batch processing with LRN Activation Date (the date a
number was ported) — a compliance and fraud-detection signal no competitor provides.