> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer.wealthatlas.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer.wealthatlas.com/_mcp/server.

# Check people against your network

POST https://api.wealthatlas.com/v1/partners/networks/connections
Content-Type: application/json

Submit a list of person IDs and see how connected each one is to your network members. Returns every person ranked by connection strength, including those with zero connections. This is the bulk version of 'Check a person against your network'.

**Cost: 1 credit.**

Reference: https://developer.wealthatlas.com/api-reference/network/compare-prospects

## Authentication

- `x-api-key` header (required) — Your WealthAtlas API key. Contact support@wealthatlas.com to get started.

## Request

### Body (application/json)

This endpoint expects a CompareRequest.

- `person_ids` (list of string, required) — Prospect person IDs to evaluate
- `in_network_person_ids` (list of string, optional, nullable) — Specific network members to compare against. If omitted, all members of the network are used
- `min_strength` (double, optional, default: 0.45) — Minimum connection strength, which must be at least 0.45. Connections below that threshold are not stored because they represent relationships that we've determined are too weak to be useful

## Response

### 200

Successful Response

- `results` (list of CompareResult, required)

## Errors

### 402 Payment Required Error

Out of credits in the bucket this endpoint charges (buckets are strictly isolated)

- `error` (string, required)
- `message` (string, required)
- `bucket` (string, required) — The credit bucket that was exhausted
- `available_credits` (integer, required)

### 422 Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

## Types

### CompareResult

A prospect ranked by their connections to network members

- `person_id` (string, required)
- `max_strength` (double, required) — Strongest connection strength to any network member
- `total_connections` (integer, required) — Total number of connections to network members
- `connections` (list of ConnectionDetail, required)
- `person` (PersonCard, optional, nullable) — Profile. Null if the person ID was not found

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)
- `input` (any, optional)
- `ctx` (ValidationErrorCtx, optional)

### ConnectionDetail

A connection between a network member and another person through a shared organization

- `source_person` (PersonCard, required) — The network member who creates this connection
- `strength` (double, required) — Connection strength from 0.0 (weak) to 1.0 (strong)
- `snippet` (string, optional, nullable) — Brief human-readable label, e.g. 'Same board, 4 years overlap'
- `connecting_entity_name` (string, optional, nullable) — Name of the shared organization, e.g. 'American Red Cross'
- `connecting_entity_type` (string, optional, nullable) — Type of shared organization: 'nonprofit', 'company', or 'school'
- `source_relationship` (string, optional, nullable) — How the network member relates to the entity, e.g. 'sits_on_board_of', 'works_for', 'donates_to'
- `target_relationship` (string, optional, nullable) — How the prospect relates to the entity

### PersonCard

A person summary card. Matches the shape returned by the search endpoint

- `id` (string, required) — WealthAtlas person ID
- `name` (string, optional, default: ) — Full name
- `bio` (string, optional, default: ) — Short biography
- `city` (string, optional, default: ) — City of residence
- `state` (string, optional, default: ) — State of residence
- `giving_capacity` (integer, optional, nullable) — Estimated annual giving capacity in dollars
- `net_worth_min` (integer, optional, nullable) — Minimum estimated net worth in dollars
- `net_worth_max` (integer, optional, nullable) — Maximum estimated net worth in dollars
- `primary_photo` (string, optional, nullable) — A signed URL for the primary photo, valid for at least an hour. Fetch the image when you need it rather than storing the URL

### ValidationErrorLocItems

- string
- integer

### ValidationErrorCtx

## Examples

**Request**

```json
{
  "person_ids": [
    "prospect_1",
    "prospect_2"
  ]
}
```

**Response**

```json
{
  "results": [
    {
      "person_id": "string",
      "max_strength": 1.1,
      "total_connections": 1,
      "connections": [
        {
          "source_person": {
            "id": "string",
            "name": "",
            "bio": "",
            "city": "",
            "state": "",
            "giving_capacity": 1,
            "net_worth_min": 1,
            "net_worth_max": 1,
            "primary_photo": "string"
          },
          "strength": 1.1,
          "snippet": "string",
          "connecting_entity_name": "string",
          "connecting_entity_type": "string",
          "source_relationship": "string",
          "target_relationship": "string"
        }
      ],
      "person": {
        "id": "string",
        "name": "",
        "bio": "",
        "city": "",
        "state": "",
        "giving_capacity": 1,
        "net_worth_min": 1,
        "net_worth_max": 1,
        "primary_photo": "string"
      }
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.wealthatlas.com/v1/partners/networks/connections"

payload = { "person_ids": ["prospect_1", "prospect_2"] }
headers = {
    "x-api-key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.wealthatlas.com/v1/partners/networks/connections';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"person_ids":["prospect_1","prospect_2"]}'
};

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://api.wealthatlas.com/v1/partners/networks/connections"

	payload := strings.NewReader("{\n  \"person_ids\": [\n    \"prospect_1\",\n    \"prospect_2\"\n  ]\n}")

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

	req.Header.Add("x-api-key", "<apiKey>")
	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://api.wealthatlas.com/v1/partners/networks/connections")

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

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"person_ids\": [\n    \"prospect_1\",\n    \"prospect_2\"\n  ]\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://api.wealthatlas.com/v1/partners/networks/connections")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"person_ids\": [\n    \"prospect_1\",\n    \"prospect_2\"\n  ]\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.wealthatlas.com/v1/partners/networks/connections', [
  'body' => '{
  "person_ids": [
    "prospect_1",
    "prospect_2"
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.wealthatlas.com/v1/partners/networks/connections");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"person_ids\": [\n    \"prospect_1\",\n    \"prospect_2\"\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "x-api-key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["person_ids": ["prospect_1", "prospect_2"]] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.wealthatlas.com/v1/partners/networks/connections")! 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()
```