> ## Documentation Index
> Fetch the complete documentation index at: https://docs.parcha.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Address Verification Check

> Verify business addresses and validate physical location presence

The Address Verification check validates that a business operates from a legitimate physical address and identifies any additional addresses associated with the business. This check helps detect virtual offices, mail drops, and other address-related risks.

## Overview

The check examines:

* Physical address validation
* Address type identification (residential, commercial, PO Box, etc.)
* Multiple address associations
* Address consistency across sources
* Geographic verification

## Running the Check

### API Endpoint

```bash theme={null}
POST https://api.parcha.ai/api/v1/startKYBAgentJob
```

### Request Parameters

<Warning>
  **Important**: You must use your own agent key, not a default or public agent key. Your agent key can be found in the Parcha dashboard under your agent's settings, or in the "Test API Integration" dialog.
</Warning>

<ParamField body="agent_key" type="string" required>
  Your KYB agent key from the Parcha dashboard. This is unique to your organization and agent configuration.
</ParamField>

<ParamField body="check_id" type="string" required>
  Use `"kyb.addresses_check"` for address verification.
</ParamField>

<ParamField body="payload" type="object" required>
  The business information for verification.

  <Expandable title="Payload Properties">
    <ParamField body="id" type="string" required>
      A unique identifier for this check case.
    </ParamField>

    <ParamField body="self_attested_data" type="object" required>
      <ParamField body="business_name" type="string" required>
        The legal name of the business to verify.
      </ParamField>

      <ParamField body="address_of_operation" type="object" required>
        <ParamField body="street_address" type="string" required>
          The street address of the business.
        </ParamField>

        <ParamField body="city" type="string" required>
          The city where the business is located.
        </ParamField>

        <ParamField body="state" type="string" required>
          The state or region where the business is located.
        </ParamField>

        <ParamField body="postal_code" type="string" required>
          The postal or ZIP code.
        </ParamField>

        <ParamField body="country_code" type="string" required>
          The country code (ISO 3166-1 alpha-2).
        </ParamField>
      </ParamField>

      <ParamField body="address_of_incorporation" type="object">
        Registered address if different from operational address.
      </ParamField>
    </ParamField>
  </Expandable>
</ParamField>

### Example Request

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST 'https://api.parcha.ai/api/v1/startKYBAgentJob' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "agent_key": "your-kyb-agent-key",
    "check_id": "kyb.addresses_check",
    "payload": {
      "id": "address-check-001",
      "self_attested_data": {
        "business_name": "Acme Corporation",
        "address_of_operation": {
          "street_address": "123 Main Street",
          "city": "San Francisco",
          "state": "CA",
          "postal_code": "94102",
          "country_code": "US"
        }
      }
    }
  }'
  ```

  ```python Python theme={null}
  import requests

  api_key = 'YOUR_API_KEY'
  url = 'https://api.parcha.ai/api/v1/startKYBAgentJob'

  headers = {
      'Authorization': f'Bearer {api_key}',
      'Content-Type': 'application/json'
  }

  data = {
      'agent_key': 'your-kyb-agent-key',  # Replace with your actual agent key
      'check_id': 'kyb.addresses_check',
      'payload': {
          'id': 'address-check-001',
          'self_attested_data': {
              'business_name': 'Acme Corporation',
              'address_of_operation': {
                  'street_address': '123 Main Street',
                  'city': 'San Francisco',
                  'state': 'CA',
                  'postal_code': '94102',
                  'country_code': 'US'
              }
          }
      }
  }

  response = requests.post(url, json=data, headers=headers)
  print(response.json())
  ```

  ```typescript TypeScript theme={null}
  import axios from 'axios';

  const apiKey = 'YOUR_API_KEY';
  const url = 'https://api.parcha.ai/api/v1/startKYBAgentJob';

  const data = {
    agent_key: 'your-kyb-agent-key',  // Replace with your actual agent key
    check_id: 'kyb.addresses_check',
    payload: {
      id: 'address-check-001',
      self_attested_data: {
        business_name: 'Acme Corporation',
        address_of_operation: {
          street_address: '123 Main Street',
          city: 'San Francisco',
          state: 'CA',
          postal_code: '94102',
          country_code: 'US'
        }
      }
    }
  };

  axios.post(url, data, {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    }
  })
  .then(response => console.log(response.data))
  .catch(error => console.error('Error:', error));
  ```
</CodeGroup>

### Initial Response

```json theme={null}
{
  "id": "job-abc123",
  "status": "PENDING",
  "created_at": "2024-02-15T10:30:00Z",
  "updated_at": "2024-02-15T10:30:00Z",
  "agent_id": "your-agent-key",
  "input_payload": {
    // Original request payload
  }
}
```

## Retrieving Check Results

Once the job is complete, retrieve the results using the job ID with the `getJobByID` endpoint. Make sure to include the `include_check_results=true` parameter to get the full check results.

```bash theme={null}
GET https://api.parcha.ai/api/v1/getJobByID?job_id=job-abc123&include_check_results=true
```

## Check Process

The address verification check follows these steps:

1. **Address Validation**
   * Validates address format and completeness
   * Verifies address exists in postal databases
   * Checks for geocoding accuracy

2. **Address Type Detection**
   * Identifies if address is residential, commercial, or mixed-use
   * Detects PO Boxes, mail forwarding services, or virtual offices
   * Flags registered agent addresses

3. **Cross-Reference Analysis**
   * Compares operational address with incorporation address
   * Searches for additional addresses associated with the business
   * Validates address consistency across data sources

4. **Risk Assessment**
   * Evaluates address legitimacy for business operations
   * Identifies high-risk address types
   * Assesses physical presence indicators

## Check Results

### Response Structure

```typescript theme={null}
{
  type: "AddressesCheckResult";
  passed: boolean;
  operational_address: AddressValidation;
  incorporation_address?: AddressValidation;
  additional_addresses?: Array<AddressInfo>;
  risk_flags?: Array<RiskFlag>;
}

type AddressValidation = {
  address: string;
  validated: boolean;
  address_type: "commercial" | "residential" | "mixed" | "po_box" | "virtual" | "registered_agent";
  geocoded: boolean;
  coordinates?: {
    latitude: number;
    longitude: number;
  };
  verification_source?: string;
}

type RiskFlag = {
  type: string;
  severity: "low" | "medium" | "high";
  description: string;
}
```

### Example Results

<CodeGroup>
  ```json Low Risk theme={null}
  {
    "type": "AddressesCheckResult",
    "passed": true,
    "operational_address": {
      "address": "123 Main Street, San Francisco, CA 94102",
      "validated": true,
      "address_type": "commercial",
      "geocoded": true,
      "coordinates": {
        "latitude": 37.7749,
        "longitude": -122.4194
      },
      "verification_source": "Google Places"
    },
    "additional_addresses": [],
    "risk_flags": []
  }
  ```

  ```json Medium Risk theme={null}
  {
    "type": "AddressesCheckResult",
    "passed": true,
    "operational_address": {
      "address": "456 Oak Avenue, Austin, TX 78701",
      "validated": true,
      "address_type": "residential",
      "geocoded": true,
      "coordinates": {
        "latitude": 30.2672,
        "longitude": -97.7431
      }
    },
    "risk_flags": [
      {
        "type": "residential_address",
        "severity": "medium",
        "description": "Business operates from a residential address"
      }
    ]
  }
  ```

  ```json High Risk theme={null}
  {
    "type": "AddressesCheckResult",
    "passed": false,
    "operational_address": {
      "address": "PO Box 1234, Wilmington, DE 19850",
      "validated": true,
      "address_type": "po_box",
      "geocoded": false
    },
    "risk_flags": [
      {
        "type": "invalid_address_type",
        "severity": "high",
        "description": "PO Box addresses are not acceptable for business operations"
      },
      {
        "type": "no_physical_presence",
        "severity": "high",
        "description": "No verifiable physical business location found"
      }
    ]
  }
  ```
</CodeGroup>

## Risk Factors

The check may flag concerns if:

* Address is a PO Box or mail forwarding service
* Address is a registered agent address (common in Delaware)
* Address is a virtual office with no physical presence
* Address cannot be validated or geocoded
* Multiple businesses operate from the same residential address
* Operational address differs significantly from incorporation address
* Address is in a high-risk jurisdiction

## Best Practices

1. **Require Physical Addresses**: Don't accept PO Boxes for business operations
2. **Verify Consistency**: Ensure addresses match across documents
3. **Check Multiple Sources**: Cross-reference with business directories and government databases
4. **Document Changes**: Track address changes over time
5. **Combine with Other Checks**: Use alongside incorporation and business profile checks

## Related Checks

* [Proof of Address Document Verification](/checks/proof-of-address-document-verification) - Verify address documents
* [Incorporation Document Verification](/checks/incorporation-document-verification) - Verify registration address
* [Basic Business Profile Check](/checks/basic-business-profile-check) - Verify overall business profile
* [Web Presence Check](/checks/web-presence-check) - Verify online presence includes address