` - Filter by section (indications, limitations, documentation) * `--type ` - Policy type (LCD, Article, NCD) * `--jurisdiction
` - MAC jurisdiction
* `--limit ` - Results per page (1-100)

**Example:**

```bash
verity coverage search "BMI greater than 40" --section indications --type LCD
```

verity spending  [#verity-spending-codes]

Get Medicaid spending data by HCPCS code.

**Flags:**

* `--year ` - Filter to a specific year

**Example:**

```bash
verity spending T1019 T1020 --year 2023
```

Shell Completion [#shell-completion]

Generate shell completion scripts:

```bash
# Bash
verity completion bash > /usr/local/etc/bash_completion.d/verity

# Zsh
verity completion zsh > /usr/local/share/zsh/site-functions/_verity

# Fish
verity completion fish > ~/.config/fish/completions/verity.fish

# PowerShell
verity completion powershell | Out-String | Invoke-Expression
```

Building from Source [#building-from-source]

```bash
git clone https://github.com/backworkai/verity-cli.git
cd verity-cli
go mod tidy
go build -o verity .
./verity --help
```

**Build for all platforms:**

```bash
make build-all
# Creates binaries in dist/ for:
# - darwin/amd64, darwin/arm64
# - linux/amd64, linux/arm64
# - windows/amd64
```

Resources [#resources]

* **GitHub**: [backworkai/verity-cli](https://github.com/backworkai/verity-cli)
* **Releases**: [Download Binaries](https://github.com/backworkai/verity-cli/releases)
* **API Reference**: [All Endpoints](/docs/api)
* **Issues**: [Report a bug](https://github.com/backworkai/verity-cli/issues)

Next Steps [#next-steps]


  

  

  



# SDKs & Libraries
URL: /docs/sdks

Official SDKs and tools for integrating Verity into your application



Build with Verity using our official SDKs for popular languages and platforms.

Server-Side SDKs [#server-side-sdks]


  

  

  

  


Command Line [#command-line]


  


Community SDKs [#community-sdks]

Don't see your language? We'd love your help building a community SDK. Check out the [API reference](/docs/api) to get started.

Features [#features]

All official SDKs include:

* **Full API Coverage** - All endpoints, parameters, and response types
* **Type Safety** - Complete type definitions and IntelliSense support
* **Error Handling** - Structured errors with helpful messages
* **Automatic Retries** - Built-in exponential backoff for transient failures
* **Modern Async** - Promise/async/await patterns throughout
* **Well Documented** - Comprehensive guides and code examples

Installation Quick Links [#installation-quick-links]


  
    ```bash
    pip install verity-python
    ```

    [View Python Docs →](/docs/sdks/python)
  

  
    ```bash
    npm install verity-api
    ```

    [View TypeScript Docs →](/docs/sdks/typescript)
  

  
    ```bash
    git clone https://github.com/backworkai/verity-ruby.git
    cd verity-ruby
    bundle install
    ```

    [View Ruby Docs →](/docs/sdks/ruby)
  

  
    ```bash
    git clone https://github.com/backworkai/verity-cli.git
    cd verity-cli
    go mod tidy
    go build -o verity .
    sudo mv verity /usr/local/bin/
    ```

    [View Go Docs →](/docs/sdks/go)
  

  
    ```bash
    dotnet add package Verity.SDK
    ```

    [View .NET Docs →](/docs/sdks/dotnet)
  


Need Help? [#need-help]

* **API Reference**: [All Endpoints](/docs/api)
* **Authentication**: [API Keys](/docs/authentication)
* **Support**: [support@verity.backworkai.com](mailto:support@verity.backworkai.com)
* **GitHub**: [Report an issue](https://github.com/backworkai)


# Python SDK
URL: /docs/sdks/python

Official Verity SDK for Python with type hints and modern async support



The Verity Python SDK gives you clean, typed access to Medicare coverage intelligence. Built for data science workflows and backend services.

Installation [#installation]

```bash
pip install verity-python
```

Requires Python 3.8+. Works with any HTTP client under the hood (uses httpx).

Quick start [#quick-start]

```python
from verity import VerityClient

client = VerityClient(api_key="vrt_live_YOUR_API_KEY")

# Make your first request
health = client.health()
print(health["data"]["status"])  # "healthy"
```

Get your API key from the [Developer Console](/console/keys).

Authentication [#authentication]

```python
from verity import VerityClient
import os

# Pass directly
client = VerityClient(api_key="vrt_live_YOUR_API_KEY")

# Or from environment
client = VerityClient(api_key=os.getenv("VERITY_API_KEY"))

# Custom base URL for testing
client = VerityClient(
    api_key="vrt_live_YOUR_API_KEY",
    base_url="https://staging.verity.backworkai.com/api/v1"
)
```

Common scenarios [#common-scenarios]

Check if a procedure needs prior auth [#check-if-a-procedure-needs-prior-auth]

Most prior auth checks fail because you don't know what documentation to include. The API tells you exactly what's required.

```python
result = client.check_prior_auth(
    procedure_codes=["27447"],  # Total knee replacement
    diagnosis_codes=["M17.11"],  # Unilateral primary osteoarthritis, right knee
    state="TX"
)

if result["data"]["pa_required"]:
    print(f"Warning: Prior authorization required")
    print(f"Confidence: {result['data']['confidence']}")
    print(f"Reason: {result['data']['reason']}")
    
    # Show exact documentation requirements
    print("\nYou need:")
    for item in result["data"]["documentation_checklist"]:
        print(f"  • {item}")
    
    # Show which policies triggered this
    print(f"\nBased on {len(result['data']['matched_policies'])} policies:")
    for policy in result["data"]["matched_policies"][:3]:
        print(f"  • {policy['policy_id']}: {policy['title']}")
```

**Output:**

```
Warning: Prior authorization required
Confidence: high
Reason: Procedure requires review of medical necessity

You need:
  • X-ray documentation showing degenerative joint disease
  • Conservative treatment history (6+ weeks)
  • Functional assessment scores
  • BMI documentation

Based on 8 policies:
  • L33822: Total Knee Replacement
  • A57305: Billing and Coding: Joint Replacement
```

The `confidence` field tells you how reliable this is. `high` means multiple policies agree. `low` means it's ambiguous or jurisdiction-dependent.

Look up codes with reimbursement data [#look-up-codes-with-reimbursement-data]

```python
result = client.lookup_code(
    code="76942",
    include=["rvu", "policies"]
)

code_data = result["data"]
print(f"{code_data['code']}: {code_data['description']}")

# RVU data is current year (2026)
if code_data.get("rvu"):
    rvu = code_data["rvu"]
    print(f"\nReimbursement:")
    print(f"  Work RVU: {rvu['work_rvu']}")
    print(f"  Facility: ${rvu['facility_price']}")
    print(f"  Non-facility: ${rvu['non_facility_price']}")

# Coverage policies show disposition by jurisdiction
if code_data.get("policies"):
    print(f"\nCoverage: {len(code_data['policies'])} policies found")
    
    covered = sum(1 for p in code_data["policies"] if p["disposition"] == "covered")
    not_covered = sum(1 for p in code_data["policies"] if p["disposition"] == "not_covered")
    
    print(f"  Covered: {covered}")
    print(f"  Not covered: {not_covered}")
    print(f"  Conditional: {len(code_data['policies']) - covered - not_covered}")
```

Search policies by keyword or semantically [#search-policies-by-keyword-or-semantically]

```python
# Keyword search (fast, exact matches)
result = client.list_policies(
    q="continuous glucose monitoring",
    policy_type="LCD",
    status="active",
    limit=10
)

print(f"Found {len(result['data'])} active LCDs\n")

for policy in result["data"]:
    print(f"{policy['policy_id']}: {policy['title']}")
    print(f"  Jurisdiction: {policy.get('jurisdiction', 'National')}")
    print(f"  Effective: {policy.get('effective_date', 'N/A')}")
```

Semantic search (slower but finds related concepts):

```python
result = client.list_policies(
    q="devices that monitor blood sugar levels",
    mode="semantic",  # Uses embedding similarity
    limit=10
)
```

Semantic search finds policies about CGM devices even though you didn't use the exact term. It's slower (\~2-3x) but more flexible.

Compare coverage across MACs [#compare-coverage-across-macs]

Medicare coverage isn't national. A procedure covered in Texas (JM) might not be covered in Pennsylvania (J05).

```python
result = client.compare_policies(
    procedure_codes=["76942"],
    jurisdictions=["J05", "J06", "J12", "JM"]
)

for juris in result["data"]["comparison"]:
    print(f"\n{juris['jurisdiction']} - {juris['mac_name']}")
    print(f"States: {', '.join(juris['states'])}")
    print(f"Policies: {len(juris['policies'])}")
    
    for policy in juris["policies"]:
        print(f"  • {policy['policy_id']}: {policy['disposition']}")
```

This shows you exactly where coverage differs. Useful for multi-state practices or national payers.

Monitor policy changes [#monitor-policy-changes]

Policies change constantly. New LCDs get published, existing ones get retired, criteria get updated.

```python
from datetime import datetime, timedelta

# Get changes from the last 7 days
seven_days_ago = (datetime.now() - timedelta(days=7)).isoformat() + "Z"

result = client.get_policy_changes(
    since=seven_days_ago,
    change_type="updated",
    limit=20
)

print(f"Policy updates in the last 7 days: {len(result['data'])}\n")

for change in result["data"]:
    print(f"{change['policy_id']}: {change['change_type']}")
    print(f"  {change.get('change_summary', 'No summary available')}")
    print(f"  {change['timestamp']}\n")
```

Use this to stay current without manually checking payer portals.

Get full policy details with criteria [#get-full-policy-details-with-criteria]

```python
result = client.get_policy(
    policy_id="L33831",
    include=["criteria", "codes", "attachments"]
)

policy = result["data"]

print(f"{policy['title']}")
print(f"Type: {policy['policy_type']} | Status: {policy['status']}")
print(f"Effective: {policy.get('effective_date', 'N/A')}\n")

# Coverage criteria are AI-extracted from the PDF
if policy.get("criteria"):
    print("Coverage Criteria:")
    for section, blocks in policy["criteria"].items():
        print(f"\n{section.upper()}:")
        for block in blocks[:3]:
            print(f"  • {block.get('text', '')[:100]}...")

# Show which codes this policy covers
if policy.get("codes"):
    print(f"\nCovers {len(policy['codes'])} codes:")
    for code in policy["codes"][:10]:
        print(f"  • {code['code']} ({code['code_system']}): {code['disposition']}")
```

The `criteria` field contains structured text blocks extracted from the policy PDF. They're tagged by section (indications, limitations, documentation, etc.) and searchable via the `/coverage/criteria` endpoint.

Search specific coverage criteria [#search-specific-coverage-criteria]

Sometimes you need to find policies with specific requirements (e.g., BMI cutoffs, frequency limits).

```python
result = client.search_criteria(
    q="BMI greater than 40",
    section="indications",
    policy_type="LCD",
    limit=10
)

print("Policies with BMI > 40 requirement:\n")

for criteria in result["data"]:
    print(f"{criteria['policy_id']} ({criteria['section']})")
    print(f"  {criteria['text'][:150]}...")
    print(f"  Tags: {', '.join(criteria.get('tags', []))}\n")
```

This is useful for finding policies with specific clinical criteria without reading every LCD.

List MAC jurisdictions [#list-mac-jurisdictions]

```python
result = client.list_jurisdictions()

print("Medicare Administrative Contractors:\n")

for juris in result["data"]:
    print(f"{juris['jurisdiction_code']}: {juris['mac_name']}")
    print(f"  States: {', '.join(juris.get('states', []))}")
    print(f"  Type: {juris.get('mac_type', 'N/A')}\n")
```

Research prior auth with AI web search [#research-prior-auth-with-ai-web-search]

For commercial payers or when you need real-time payer website intelligence:

```python
# Async mode (default) - returns research_id for polling
result = client.research_prior_auth(
    procedure_codes=["27447"],
    payer="UnitedHealthcare",
    state="TX"
)

research_id = result["data"]["research_id"]
print(f"Research started: {research_id}")

# Poll for results
import time
while True:
    status = client.get_prior_auth_research(research_id)
    if status["data"]["status"] in ("completed", "failed"):
        break
    time.sleep(2)

if status["data"]["status"] == "completed":
    determination = status["data"]["result"]["determination"]
    print(f"PA Required: {determination['pa_required']}")
    print(f"Reasoning: {determination['reasoning']}")

# Or use sync mode to wait for completion
result = client.research_prior_auth(
    procedure_codes=["27447"],
    payer="Aetna",
    state="CA",
    sync=True  # Blocks until complete
)
print(result["data"]["result"]["determination"])
```

Get Medicaid spending data [#get-medicaid-spending-data]

```python
# Single code
result = client.get_spending_by_code(code="T1019")
spending = result["data"]["T1019"]
print(f"Total paid: ${spending['total_paid']}")
print(f"Total claims: {spending['total_claims']}")

for year in spending["by_year"]:
    print(f"  {year['year']}: ${year['total_paid']} ({year['total_claims']} claims)")

# Multiple codes with year filter
result = client.get_spending_by_code(codes=["T1019", "T1020"], year=2023)
```

Error handling [#error-handling]

The SDK raises structured exceptions. Catch them specifically, not just generic `Exception`.

```python
from verity import (
    VerityClient,
    VerityError,
    AuthenticationError,
    ValidationError,
    NotFoundError,
    RateLimitError
)

client = VerityClient(api_key="vrt_live_YOUR_API_KEY")

try:
    result = client.lookup_code(code="INVALID")
except AuthenticationError:
    print("Invalid API key")
except ValidationError as e:
    print(f"Bad request: {e.message}")
    if e.details:
        print(f"Details: {e.details}")
except NotFoundError:
    print("Code not found")
except RateLimitError as e:
    print(f"Rate limited. Resets in {e.reset - time.time():.0f}s")
except VerityError as e:
    print(f"API error: {e.message} (code: {e.code})")
```

Don't catch `VerityError` at the top level unless you're doing generic error handling. Catch specific exceptions first.

Response format [#response-format]

All methods return dictionaries matching this structure:

```python
{
    "success": True,
    "data": { ... },  # The actual response
    "meta": {
        "request_id": "req_...",
        "timestamp": "2026-01-25T12:00:00Z"
    }
}
```

Error responses:

```python
{
    "success": False,
    "error": {
        "code": "VALIDATION_ERROR",
        "message": "Invalid parameter: code",
        "hint": "Code must be a valid CPT, HCPCS, or ICD-10 code"
    }
}
```

Type hints [#type-hints]

The SDK includes type hints for IDE autocomplete. Use them.

```python
from verity import VerityClient
from typing import Dict, Any

client = VerityClient(api_key="vrt_live_YOUR_API_KEY")

# Type checker knows what parameters are valid
result: Dict[str, Any] = client.lookup_code(
    code="76942",
    include=["rvu", "policies"],  # IDE suggests valid values
    jurisdiction="JM",
    fuzzy=True
)

# Access with confidence
if result["success"]:
    description: str = result["data"]["description"]
    found: bool = result["data"]["found"]
```

Advanced configuration [#advanced-configuration]

Custom timeout [#custom-timeout]

```python
client = VerityClient(
    api_key="vrt_live_YOUR_API_KEY",
    timeout=60  # seconds
)
```

Automatic retries [#automatic-retries]

The SDK retries transient failures (rate limits, timeouts) with exponential backoff. Max 3 retries by default. This is automatic—you don't need to configure it.

What the SDK doesn't do [#what-the-sdk-doesnt-do]

The SDK wraps the REST API. It doesn't:

* Cache responses (build your own cache if needed)
* Batch requests (send them concurrently if you need parallelism)
* Make coverage decisions (it returns what's in the policies, you interpret them)

These are intentional design choices. The SDK is low-level and unopinionated.

Resources [#resources]

* **PyPI**: [verity-python](https://pypi.org/project/verity-python/)
* **GitHub**: [backworkai/verity-python](https://github.com/backworkai/verity-python)
* **API Reference**: [All Endpoints](/docs/api)
* **Issues**: [Report a bug](https://github.com/backworkai/verity-python/issues)

Next steps [#next-steps]


  

  

  

  



# Ruby SDK
URL: /docs/sdks/ruby

Official Verity SDK for Ruby with resource-oriented API clients



The Verity Ruby SDK provides resource-oriented access to Medicare coverage intelligence, medical code lookup, policies, coverage criteria, prior authorization checks, spending data, and webhooks.


  The Ruby SDK is not published to RubyGems yet. Install from source until the first package release is cut.


Installation [#installation]

```bash
git clone https://github.com/backworkai/verity-ruby.git
cd verity-ruby
bundle install
```

Requires Ruby 2.7+.

Quick Start [#quick-start]

```ruby
require 'verity'

client = Verity::Client.new(api_key: 'vrt_live_YOUR_API_KEY')

health = client.health
puts health.dig('data', 'status')
```

Get your API key from the [Developer Console](/console/keys).

Authentication [#authentication]

```ruby
client = Verity::Client.new(
  api_key: ENV.fetch('VERITY_API_KEY'),
  base_url: 'https://verity.backworkai.com/api/v1'
)
```

Common Use Cases [#common-use-cases]

Look Up a Medical Code [#look-up-a-medical-code]

```ruby
result = client.codes.lookup('76942', include: ['rvu', 'policies'])

data = result['data']
puts "#{data['code']}: #{data['description']}"
puts "Policies: #{data['policies']&.length || 0}"
```

Search Policies [#search-policies]

```ruby
result = client.policies.list(
  q: 'ultrasound guidance',
  mode: 'keyword',
  policy_type: 'LCD',
  jurisdiction: 'JM',
  limit: 10
)

result['data'].each do |policy|
  puts "#{policy['policy_id']}: #{policy['title']}"
end
```

Check Prior Authorization [#check-prior-authorization]

```ruby
result = client.prior_auth.check(
  procedure_codes: ['27447'],
  diagnosis_codes: ['M17.11'],
  state: 'TX',
  payer: 'Medicare'
)

data = result['data']
puts "PA required: #{data['pa_required']}"
puts "Reason: #{data['reason']}"
```

Resources [#resources]

* **GitHub**: [backworkai/verity-ruby](https://github.com/backworkai/verity-ruby)
* **API Reference**: [All Endpoints](/docs/api)
* **Issues**: [Report a bug](https://github.com/backworkai/verity-ruby/issues)


# TypeScript SDK
URL: /docs/sdks/typescript

Official Verity SDK for TypeScript and Node.js with full type definitions



The official Verity TypeScript SDK provides a type-safe way to integrate Medicare coverage intelligence into your TypeScript, JavaScript, and Node.js applications.

Installation [#installation]

Install via npm, yarn, or pnpm:

```bash
npm install verity-api
# or
yarn add verity-api
# or
pnpm add verity-api
```

**Requirements**: Node.js 18+ or modern browser with fetch API

Quick Start [#quick-start]

```typescript
import { VerityClient } from 'verity-api';

// Initialize the client
const client = new VerityClient('vrt_live_YOUR_API_KEY');

// Make your first request
const health = await client.health();
console.log(health.data.status);  // "healthy"
```

Authentication [#authentication]

Set your API key when initializing the client:

```typescript
import { VerityClient } from 'verity-api';

// Option 1: Pass directly
const client = new VerityClient('vrt_live_YOUR_API_KEY');

// Option 2: With configuration object
const client = new VerityClient({
  apiKey: 'vrt_live_YOUR_API_KEY',
  baseUrl: 'https://verity.backworkai.com/api/v1',  // optional
  timeout: 30000  // optional, in milliseconds
});

// Option 3: From environment variable
const client = new VerityClient(process.env.VERITY_API_KEY!);
```

Get your API key from the [Developer Console](/console/keys).

Common Use Cases [#common-use-cases]

Check if a Procedure Needs Prior Authorization [#check-if-a-procedure-needs-prior-authorization]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Check for a knee replacement in Texas
const result = await client.checkPriorAuth({
  procedureCodes: ['27447'],  // Total knee replacement
  diagnosisCodes: ['M17.11'],  // Unilateral primary osteoarthritis, right knee
  state: 'TX'
});

if (result.data.pa_required) {
  console.log('Warning: Prior authorization required!');
  console.log(`Confidence: ${result.data.confidence}`);
  console.log(`Reason: ${result.data.reason}`);
  
  // Show what documentation is needed
  console.log('\nDocumentation checklist:');
  result.data.documentation_checklist?.forEach(item => {
    console.log(`  • ${item}`);
  });
  
  // Show matched policies
  console.log(`\nMatched ${result.data.matched_policies?.length} policies:`);
  result.data.matched_policies?.slice(0, 3).forEach(policy => {
    console.log(`  • ${policy.policy_id}: ${policy.title}`);
  });
} else {
  console.log('No prior authorization needed');
}
```

Look Up Procedure Code with Coverage Info [#look-up-procedure-code-with-coverage-info]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Look up a code with RVU data and policies
const result = await client.lookupCode({
  code: '76942',  // Ultrasound guidance
  include: ['rvu', 'policies']
});

const codeData = result.data;
console.log(`Code: ${codeData.code}`);
console.log(`Description: ${codeData.description}`);

// Show reimbursement info
if (codeData.rvu) {
  console.log('\nReimbursement (2026):');
  console.log(`  Work RVU: ${codeData.rvu.work_rvu}`);
  console.log(`  Facility price: $${codeData.rvu.facility_price}`);
  console.log(`  Non-facility price: $${codeData.rvu.non_facility_price}`);
}

// Show coverage policies
if (codeData.policies) {
  console.log(`\nFound ${codeData.policies.length} coverage policies:`);
  codeData.policies.slice(0, 5).forEach(policy => {
    console.log(`  • [${policy.disposition}] ${policy.title}`);
  });
}
```

Search Coverage Policies by Keyword [#search-coverage-policies-by-keyword]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Search for policies about diabetes CGM devices
const result = await client.listPolicies({
  q: 'continuous glucose monitoring diabetes',
  policyType: 'LCD',  // Local Coverage Determinations
  status: 'active',
  limit: 10
});

console.log(`Found ${result.data.length} active LCDs about CGM:\n`);

result.data.forEach(policy => {
  console.log(`Policy: ${policy.policy_id}`);
  console.log(`Title: ${policy.title}`);
  console.log(`Jurisdiction: ${policy.jurisdiction || 'National'}`);
  console.log(`Effective: ${policy.effective_date || 'N/A'}`);
  console.log('---');
});
```

Compare Coverage Across Jurisdictions [#compare-coverage-across-jurisdictions]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Compare ultrasound guidance coverage across different MACs
const result = await client.comparePolicies({
  procedureCodes: ['76942'],
  jurisdictions: ['J05', 'J06', 'J12', 'JM']  // Different MAC jurisdictions
});

const comparison = result.data.comparison;

console.log('Coverage comparison across jurisdictions:\n');
comparison?.forEach(juris => {
  console.log(`${juris.jurisdiction} (${juris.mac_name}):`);
  console.log(`  States: ${juris.states?.join(', ')}`);
  console.log(`  Policies: ${juris.policies?.length}`);
  
  juris.policies?.forEach(policy => {
    console.log(`    • ${policy.policy_id}: ${policy.disposition}`);
  });
  console.log();
});
```

Monitor Policy Changes [#monitor-policy-changes]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Get policies updated in the last 7 days
const sevenDaysAgo = new Date();
sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);

const result = await client.getPolicyChanges({
  since: sevenDaysAgo.toISOString(),
  changeType: 'updated',
  limit: 20
});

console.log('Policy changes in the last 7 days:\n');

result.data.forEach(change => {
  console.log(`Policy: ${change.policy_id}`);
  console.log(`Change: ${change.change_type}`);
  console.log(`Summary: ${change.change_summary || 'No summary'}`);
  console.log(`Timestamp: ${change.timestamp}`);
  console.log('---');
});
```

Get Detailed Policy Information [#get-detailed-policy-information]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Get full policy details with criteria
const result = await client.getPolicy('L33831', {
  include: ['criteria', 'codes', 'attachments']
});

const policy = result.data;

console.log(`Policy: ${policy.title}`);
console.log(`Type: ${policy.policy_type}`);
console.log(`Status: ${policy.status}`);
console.log(`Effective: ${policy.effective_date || 'N/A'}`);

// Show coverage criteria
if (policy.criteria) {
  console.log('\nCoverage Criteria:');
  Object.entries(policy.criteria).forEach(([section, blocks]) => {
    console.log(`\n${section.toUpperCase()}:`);
    blocks.slice(0, 3).forEach(block => {  // Show first 3
      console.log(`  • ${block.text?.substring(0, 100)}...`);
    });
  });
}

// Show covered codes
if (policy.codes) {
  console.log(`\nCovers ${policy.codes.length} codes`);
  policy.codes.slice(0, 10).forEach(code => {
    console.log(`  • ${code.code} (${code.code_system}): ${code.disposition}`);
  });
}
```

Search Coverage Criteria [#search-coverage-criteria]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Search for specific coverage criteria about BMI requirements
const result = await client.searchCriteria({
  q: 'BMI greater than 40',
  section: 'indications',
  policyType: 'LCD',
  limit: 10
});

console.log('BMI-related coverage criteria:\n');

result.data.forEach(criteria => {
  console.log(`Policy: ${criteria.policy_id}`);
  console.log(`Section: ${criteria.section}`);
  console.log(`Text: ${criteria.text?.substring(0, 200)}...`);
  console.log(`Tags: ${criteria.tags?.join(', ')}`);
  console.log('---');
});
```

List MAC Jurisdictions [#list-mac-jurisdictions]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

const result = await client.listJurisdictions();

console.log('Medicare Administrative Contractors (MACs):\n');

result.data.forEach(jurisdiction => {
  console.log(`${jurisdiction.jurisdiction_code}: ${jurisdiction.mac_name}`);
  console.log(`  States: ${jurisdiction.states?.join(', ')}`);
  console.log(`  Type: ${jurisdiction.mac_type || 'N/A'}`);
  console.log();
});
```

Research Prior Auth with AI Web Search [#research-prior-auth-with-ai-web-search]

For commercial payers or when you need real-time payer website intelligence:

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Async mode (default) - returns research_id for polling
const research = await client.researchPriorAuth({
  procedureCodes: ['27447'],
  payer: 'UnitedHealthcare',
  state: 'TX'
});

const researchId = research.data.research_id;
console.log(`Research started: ${researchId}`);

// Poll for results
let status;
do {
  await new Promise(resolve => setTimeout(resolve, 2000));
  status = await client.getPriorAuthResearch(researchId);
} while (!['completed', 'failed'].includes(status.data.status));

if (status.data.status === 'completed') {
  console.log('Determination:', status.data.result?.determination);
  console.log('Sources:', status.data.result?.sources);
}

// Or use sync mode to wait for completion
const syncResult = await client.researchPriorAuth({
  procedureCodes: ['27447'],
  payer: 'Aetna',
  state: 'CA',
  sync: true
});
console.log(syncResult.data.result?.determination);
```

Get Medicaid Spending Data [#get-medicaid-spending-data]

```typescript
import { VerityClient } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Single code
const result = await client.getSpendingByCode({ code: 'T1019' });
const spending = result.data['T1019'];
console.log(`Total paid: $${spending.total_paid}`);
console.log(`Total claims: ${spending.total_claims}`);

spending.by_year.forEach(year => {
  console.log(`  ${year.year}: $${year.total_paid} (${year.total_claims} claims)`);
});

// Multiple codes with year filter
const multi = await client.getSpendingByCode({
  codes: ['T1019', 'T1020'],
  year: 2023
});
```

Browser Usage [#browser-usage]

The SDK works in modern browsers using native fetch:

```html


Loading...
```

Error Handling [#error-handling]

The SDK provides structured exceptions for different error types:

```typescript
import {
  VerityClient,
  VerityError,
  AuthenticationError,
  ValidationError,
  NotFoundError,
  RateLimitError
} from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

try {
  const result = await client.lookupCode({ code: 'INVALID' });
} catch (error) {
  if (error instanceof AuthenticationError) {
    console.error('Invalid API key:', error.message);
  } else if (error instanceof ValidationError) {
    console.error('Invalid parameters:', error.message);
    if (error.details) {
      console.error('Details:', error.details);
    }
  } else if (error instanceof NotFoundError) {
    console.error('Resource not found:', error.message);
  } else if (error instanceof RateLimitError) {
    console.error(`Rate limit exceeded. Resets at: ${error.reset}`);
    console.error(`Limit: ${error.limit}, Remaining: ${error.remaining}`);
  } else if (error instanceof VerityError) {
    console.error(`API error: ${error.message} (code: ${error.code})`);
    if (error.hint) {
      console.error(`Hint: ${error.hint}`);
    }
  }
}
```

Response Format [#response-format]

All methods return typed responses:

```typescript
interface ApiResponse {
  success: true;
  data: T;
  meta?: {
    request_id?: string;
    timestamp?: string;
    [key: string]: any;
  };
}

// Or error response
interface ErrorResponse {
  success: false;
  error: {
    code: string;
    message: string;
    hint?: string;
    details?: Record;
  };
  meta?: {
    request_id?: string;
    timestamp?: string;
  };
}
```

TypeScript Integration [#typescript-integration]

The SDK includes complete type definitions:

```typescript
import { VerityClient, CodeLookupData, PriorAuthResult } from 'verity-api';

const client = new VerityClient(process.env.VERITY_API_KEY!);

// Full type safety with autocomplete
const codeResult = await client.lookupCode({
  code: '76942',
  include: ['rvu', 'policies'],
  jurisdiction: 'JM',
  fuzzy: true
});

// TypeScript knows the exact shape of the response
if (codeResult.success) {
  const data: CodeLookupData = codeResult.data;
  const description: string | null = data.description;
  const found: boolean = data.found;
  const rvu = data.rvu;  // Type: RvuData | undefined
  
  console.log(`${description} - $${rvu?.facility_price}`);
}
```

Express.js Integration [#expressjs-integration]

Example Express.js endpoint using the SDK:

```typescript
import express from 'express';
import { VerityClient, VerityError } from 'verity-api';

const app = express();
const verity = new VerityClient(process.env.VERITY_API_KEY!);

app.get('/api/check-code/:code', async (req, res) => {
  try {
    const result = await verity.lookupCode({
      code: req.params.code,
      include: ['rvu', 'policies']
    });
    
    res.json(result);
  } catch (error) {
    if (error instanceof VerityError) {
      res.status(error.statusCode || 500).json({
        error: error.message,
        code: error.code
      });
    } else {
      res.status(500).json({ error: 'Internal server error' });
    }
  }
});

app.listen(3000);
```

Resources [#resources]

* **npm**: [verity-api](https://www.npmjs.com/package/verity-api)
* **GitHub**: [backworkai/verity-ts](https://github.com/backworkai/verity-ts)
* **API Reference**: [All Endpoints](/docs/api)
* **Issues**: [Report a bug](https://github.com/backworkai/verity-ts/issues)

Next Steps [#next-steps]