VerityVerity API
SDKs & Libraries

.NET SDK

Official Verity SDK for C# and .NET with async/await support

The official Verity .NET SDK provides a strongly-typed way to integrate Medicare coverage intelligence into your C#, F#, and .NET applications.

Installation

Install via NuGet Package Manager:

dotnet add package Verity.SDK

Or via Package Manager Console in Visual Studio:

Install-Package Verity.SDK

Requirements: .NET Standard 2.0+ (.NET Framework 4.6.1+, .NET Core 2.0+, .NET 5+)

Quick Start

using Verity;

// Initialize the client
var client = new VerityClient("vrt_live_YOUR_API_KEY");

// Make your first request
var health = await client.HealthAsync();
Console.WriteLine(health.Data.Status);  // "healthy"

Authentication

Set your API key when initializing the client:

using Verity;

// Option 1: Pass directly
var client = new VerityClient("vrt_live_YOUR_API_KEY");

// Option 2: With configuration
var client = new VerityClient(new VerityClientOptions
{
    ApiKey = "vrt_live_YOUR_API_KEY",
    BaseUrl = "https://verity.backworkai.com/api/v1",  // optional
    Timeout = TimeSpan.FromSeconds(30)  // optional
});

// Option 3: From configuration
var apiKey = Configuration["Verity:ApiKey"];
var client = new VerityClient(apiKey);

Get your API key from the Developer Console.

Common Use Cases

Check if a Procedure Needs Prior Authorization

using Verity;
using System;
using System.Linq;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// Check for a knee replacement in Texas
var request = new PriorAuthRequest
{
    ProcedureCodes = new[] { "27447" },  // Total knee replacement
    DiagnosisCodes = new[] { "M17.11" },  // Unilateral primary osteoarthritis, right knee
    State = "TX"
};

var result = await client.CheckPriorAuthAsync(request);

if (result.Data.PaRequired)
{
    Console.WriteLine("Warning: Prior authorization required!");
    Console.WriteLine($"Confidence: {result.Data.Confidence}");
    Console.WriteLine($"Reason: {result.Data.Reason}");
    
    // Show what documentation is needed
    Console.WriteLine("\nDocumentation checklist:");
    foreach (var item in result.Data.DocumentationChecklist ?? Enumerable.Empty<string>())
    {
        Console.WriteLine($"  • {item}");
    }
    
    // Show matched policies
    Console.WriteLine($"\nMatched {result.Data.MatchedPolicies?.Count ?? 0} policies:");
    foreach (var policy in result.Data.MatchedPolicies?.Take(3) ?? Enumerable.Empty<PolicyMatch>())
    {
        Console.WriteLine($"  • {policy.PolicyId}: {policy.Title}");
    }
}
else
{
    Console.WriteLine("No prior authorization needed");
}

Look Up Procedure Code with Coverage Info

using Verity;
using System;
using System.Linq;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// Look up a code with RVU data and policies
var request = new CodeLookupRequest
{
    Code = "76942",  // Ultrasound guidance
    Include = new[] { "rvu", "policies" }
};

var result = await client.LookupCodeAsync(request);
var codeData = result.Data;

Console.WriteLine($"Code: {codeData.Code}");
Console.WriteLine($"Description: {codeData.Description}");

// Show reimbursement info
if (codeData.Rvu != null)
{
    Console.WriteLine("\nReimbursement (2026):");
    Console.WriteLine($"  Work RVU: {codeData.Rvu.WorkRvu}");
    Console.WriteLine($"  Facility price: ${codeData.Rvu.FacilityPrice}");
    Console.WriteLine($"  Non-facility price: ${codeData.Rvu.NonFacilityPrice}");
}

// Show coverage policies
if (codeData.Policies != null)
{
    Console.WriteLine($"\nFound {codeData.Policies.Count} coverage policies:");
    foreach (var policy in codeData.Policies.Take(5))
    {
        Console.WriteLine($"  • [{policy.Disposition}] {policy.Title}");
    }
}

Search Coverage Policies by Keyword

using Verity;
using System;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// Search for policies about diabetes CGM devices
var request = new PolicySearchRequest
{
    Query = "continuous glucose monitoring diabetes",
    PolicyType = "LCD",  // Local Coverage Determinations
    Status = PolicyStatus.Active,
    Limit = 10
};

var result = await client.ListPoliciesAsync(request);

Console.WriteLine($"Found {result.Data.Count} active LCDs about CGM:\n");

foreach (var policy in result.Data)
{
    Console.WriteLine($"Policy: {policy.PolicyId}");
    Console.WriteLine($"Title: {policy.Title}");
    Console.WriteLine($"Jurisdiction: {policy.Jurisdiction ?? "National"}");
    Console.WriteLine($"Effective: {policy.EffectiveDate?.ToString("yyyy-MM-dd") ?? "N/A"}");
    Console.WriteLine("---");
}

Compare Coverage Across Jurisdictions

using Verity;
using System;
using System.Linq;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// Compare ultrasound guidance coverage across different MACs
var request = new ComparePoliciesRequest
{
    ProcedureCodes = new[] { "76942" },
    Jurisdictions = new[] { "J05", "J06", "J12", "JM" }  // Different MAC jurisdictions
};

var result = await client.ComparePoliciesAsync(request);
var comparison = result.Data.Comparison;

Console.WriteLine("Coverage comparison across jurisdictions:\n");

foreach (var juris in comparison ?? Enumerable.Empty<JurisdictionComparison>())
{
    Console.WriteLine($"{juris.Jurisdiction} ({juris.MacName}):");
    Console.WriteLine($"  States: {string.Join(", ", juris.States ?? Enumerable.Empty<string>())}");
    Console.WriteLine($"  Policies: {juris.Policies?.Count ?? 0}");
    
    foreach (var policy in juris.Policies ?? Enumerable.Empty<PolicyMatch>())
    {
        Console.WriteLine($"    • {policy.PolicyId}: {policy.Disposition}");
    }
    Console.WriteLine();
}

Monitor Policy Changes

using Verity;
using System;
using System.Linq;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// Get policies updated in the last 7 days
var sevenDaysAgo = DateTime.UtcNow.AddDays(-7);

var request = new PolicyChangesRequest
{
    Since = sevenDaysAgo,
    ChangeType = "updated",
    Limit = 20
};

var result = await client.GetPolicyChangesAsync(request);

Console.WriteLine("Policy changes in the last 7 days:\n");

foreach (var change in result.Data)
{
    Console.WriteLine($"Policy: {change.PolicyId}");
    Console.WriteLine($"Change: {change.ChangeType}");
    Console.WriteLine($"Summary: {change.ChangeSummary ?? "No summary"}");
    Console.WriteLine($"Timestamp: {change.Timestamp}");
    Console.WriteLine("---");
}

Get Detailed Policy Information

using Verity;
using System;
using System.Linq;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// Get full policy details with criteria
var result = await client.GetPolicyAsync("L33831", new GetPolicyRequest
{
    Include = new[] { "criteria", "codes", "attachments" }
});

var policy = result.Data;

Console.WriteLine($"Policy: {policy.Title}");
Console.WriteLine($"Type: {policy.PolicyType}");
Console.WriteLine($"Status: {policy.Status}");
Console.WriteLine($"Effective: {policy.EffectiveDate?.ToString("yyyy-MM-dd") ?? "N/A"}");

// Show coverage criteria
if (policy.Criteria != null)
{
    Console.WriteLine("\nCoverage Criteria:");
    foreach (var section in policy.Criteria)
    {
        Console.WriteLine($"\n{section.Key.ToUpper()}:");
        foreach (var block in section.Value.Take(3))  // Show first 3
        {
            Console.WriteLine($"  • {block.Text?.Substring(0, Math.Min(100, block.Text.Length ?? 0))}...");
        }
    }
}

// Show covered codes
if (policy.Codes != null)
{
    Console.WriteLine($"\nCovers {policy.Codes.Count} codes");
    foreach (var code in policy.Codes.Take(10))
    {
        Console.WriteLine($"  • {code.Code} ({code.CodeSystem}): {code.Disposition}");
    }
}

Search Coverage Criteria

using Verity;
using System;
using System.Linq;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// Search for specific coverage criteria about BMI requirements
var request = new CriteriaSearchRequest
{
    Query = "BMI greater than 40",
    Section = CriteriaSection.Indications,
    PolicyType = "LCD",
    Limit = 10
};

var result = await client.SearchCriteriaAsync(request);

Console.WriteLine("BMI-related coverage criteria:\n");

foreach (var criteria in result.Data)
{
    Console.WriteLine($"Policy: {criteria.PolicyId}");
    Console.WriteLine($"Section: {criteria.Section}");
    Console.WriteLine($"Text: {criteria.Text?.Substring(0, Math.Min(200, criteria.Text.Length ?? 0))}...");
    Console.WriteLine($"Tags: {string.Join(", ", criteria.Tags ?? Enumerable.Empty<string>())}");
    Console.WriteLine("---");
}

List MAC Jurisdictions

using Verity;
using System;
using System.Linq;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

var result = await client.ListJurisdictionsAsync();

Console.WriteLine("Medicare Administrative Contractors (MACs):\n");

foreach (var jurisdiction in result.Data)
{
    Console.WriteLine($"{jurisdiction.JurisdictionCode}: {jurisdiction.MacName}");
    Console.WriteLine($"  States: {string.Join(", ", jurisdiction.States ?? Enumerable.Empty<string>())}");
    Console.WriteLine($"  Type: {jurisdiction.MacType ?? "N/A"}");
    Console.WriteLine();
}

ASP.NET Core Integration

Dependency Injection Setup

// Startup.cs or Program.cs
using Microsoft.Extensions.DependencyInjection;
using Verity;

public void ConfigureServices(IServiceCollection services)
{
    // Add Verity client as a singleton
    services.AddSingleton<IVerityClient>(sp =>
    {
        var apiKey = Configuration["Verity:ApiKey"];
        return new VerityClient(apiKey);
    });
    
    services.AddControllers();
}

Using in a Controller

using Microsoft.AspNetCore.Mvc;
using Verity;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class CodesController : ControllerBase
{
    private readonly IVerityClient _verity;
    
    public CodesController(IVerityClient verity)
    {
        _verity = verity;
    }
    
    [HttpGet("{code}")]
    public async Task<IActionResult> GetCode(string code)
    {
        try
        {
            var result = await _verity.LookupCodeAsync(new CodeLookupRequest
            {
                Code = code,
                Include = new[] { "rvu", "policies" }
            });
            
            return Ok(result);
        }
        catch (VerityAuthenticationException ex)
        {
            return Unauthorized(new { error = ex.Message });
        }
        catch (VerityValidationException ex)
        {
            return BadRequest(new { error = ex.Message, details = ex.Details });
        }
        catch (VerityException ex)
        {
            return StatusCode(500, new { error = ex.Message });
        }
    }
}

Error Handling

The SDK provides structured exceptions for different error types:

using Verity;
using System;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

try
{
    var result = await client.LookupCodeAsync(new CodeLookupRequest { Code = "INVALID" });
}
catch (VerityAuthenticationException ex)
{
    Console.WriteLine($"Invalid API key: {ex.Message}");
}
catch (VerityValidationException ex)
{
    Console.WriteLine($"Invalid parameters: {ex.Message}");
    if (ex.Details != null)
    {
        Console.WriteLine($"Details: {string.Join(", ", ex.Details)}");
    }
}
catch (VerityNotFoundException ex)
{
    Console.WriteLine($"Resource not found: {ex.Message}");
}
catch (VerityRateLimitException ex)
{
    Console.WriteLine($"Rate limit exceeded. Resets at: {ex.ResetAt}");
    Console.WriteLine($"Limit: {ex.Limit}, Remaining: {ex.Remaining}");
}
catch (VerityException ex)
{
    Console.WriteLine($"API error: {ex.Message} (code: {ex.Code})");
    if (!string.IsNullOrEmpty(ex.Hint))
    {
        Console.WriteLine($"Hint: {ex.Hint}");
    }
}

Response Format

All methods return strongly-typed responses:

public class ApiResponse<T>
{
    public bool Success { get; set; }
    public T Data { get; set; }
    public ApiMeta Meta { get; set; }
}

public class ApiMeta
{
    public string RequestId { get; set; }
    public DateTime Timestamp { get; set; }
    // Additional metadata...
}

Async/Await Patterns

All SDK methods are async and follow TAP (Task-based Asynchronous Pattern):

using Verity;
using System;
using System.Threading;
using System.Threading.Tasks;

var client = new VerityClient(Environment.GetEnvironmentVariable("VERITY_API_KEY"));

// With cancellation token
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));

try
{
    var result = await client.LookupCodeAsync(
        new CodeLookupRequest { Code = "76942" },
        cts.Token
    );
}
catch (OperationCanceledException)
{
    Console.WriteLine("Request cancelled or timed out");
}

Configuration Options

using Verity;
using System;
using System.Net.Http;

var options = new VerityClientOptions
{
    ApiKey = "vrt_live_YOUR_API_KEY",
    BaseUrl = "https://verity.backworkai.com/api/v1",
    Timeout = TimeSpan.FromSeconds(60),
    
    // Custom HTTP client for advanced scenarios
    HttpClient = new HttpClient
    {
        Timeout = TimeSpan.FromMinutes(2)
    },
    
    // Enable automatic retries (default: 3)
    MaxRetries = 3,
    
    // Retry delay (exponential backoff)
    RetryDelay = TimeSpan.FromSeconds(1)
};

var client = new VerityClient(options);

Resources

Next Steps

API Reference

Explore all available endpoints

Authentication

Learn about API keys

Rate Limits

Understand usage limits

Error Handling

Handle errors gracefully

On this page

InstallationQuick StartAuthenticationCommon Use CasesCheck if a Procedure Needs Prior AuthorizationLook Up Procedure Code with Coverage InfoSearch Coverage Policies by KeywordCompare Coverage Across JurisdictionsMonitor Policy ChangesGet Detailed Policy InformationSearch Coverage CriteriaList MAC JurisdictionsASP.NET Core IntegrationDependency Injection SetupUsing in a ControllerError HandlingResponse FormatAsync/Await PatternsConfiguration OptionsResourcesNext Steps