HelloData API Documentation

https://docs.hellodata.ai/
Admin
HelloData's API provides real-time data updates on millions of multifamily properties, offering...
Tokens:111,385
Snippets:451
Trust Score:9.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### SDK Implementation Examples

Source: https://docs.hellodata.ai/api-reference/api-reference/property/post-property

Examples of how to call the POST /property endpoint using various programming languages.

```python
import requests

url = "https://api.hellodata.ai/property"

payload = { "property": {
        "street_address": "123 Main St",
        "city": "New York",
        "state": "NY",
        "zip_code": "01234",
        "lat": 40.7128,
        "lon": -74.006,
        "building_name": "The Best Building",
        "is_single_family": False,
        "is_condo": False,
        "is_apartment": True,
        "number_units": 100,
        "year_built": 2020,
        "number_stories": 10,
        "building_amenities": ["24_hour_maintenance"],
        "unit_amenities": ["air_conditioning"],
        "avg_quality": 0.8,
        "units": [
            {
                "bed": 2,
                "bath": 1,
                "name": "1A",
                "sqft": 1000,
                "price": 1000
            }
        ]
    } }
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.hellodata.ai/property';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"property":{"street_address":"123 Main St","city":"New York","state":"NY","zip_code":"01234","lat":40.7128,"lon":-74.006,"building_name":"The Best Building","is_single_family":false,"is_condo":false,"is_apartment":true,"number_units":100,"year_built":2020,"number_stories":10,"building_amenities":["24_hour_maintenance"],"unit_amenities":["air_conditioning"],"avg_quality":0.8,"units":[{"bed":2,"bath":1,"name":"1A","sqft":1000,"price":1000}]}}'
};

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.hellodata.ai/property"

	payload := strings.NewReader("{\n  \"property\": {\n    \"street_address\": \"123 Main St\",\n    \"city\": \"New York\",\n    \"state\": \"NY\",\n    \"zip_code\": \"01234\",\n    \"lat\": 40.7128,\n    \"lon\": -74.006,\n    \"building_name\": \"The Best Building\",\n    \"is_single_family\": false,\n    \"is_condo\": false,\n    \"is_apartment\": true,\n    \"number_units\": 100,\n    \"year_built\": 2020,\n    \"number_stories\": 10,\n    \"building_amenities\": [\n      \"24_hour_maintenance\"\n    ],\n    \"unit_amenities\": [\n      \"air_conditioning\"\n    ],\n    \"avg_quality\": 0.8,\n    \"units\": [\n      {\n        \"bed\": 2,\n        \"bath\": 1,\n        \"name\": \"1A\",\n        \"sqft\": 1000,\n        \"price\": 1000\n      }\n    ]\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.hellodata.ai/property")

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  \"property\": {\n    \"street_address\": \"123 Main St\",\n    \"city\": \"New York\",\n    \"state\": \"NY\",\n    \"zip_code\": \"01234\",\n    \"lat\": 40.7128,\n    \"lon\": -74.006,\n    \"building_name\": \"The Best Building\",\n    \"is_single_family\": false,\n    \"is_condo\": false,\n    \"is_apartment\": true,\n    \"number_units\": 100,\n    \"year_built\": 2020,\n    \"number_stories\": 10,\n    \"building_amenities\": [\n      \"24_hour_maintenance\"\n    ],\n    \"unit_amenities\": [\n      \"air_conditioning\"\n    ],\n    \"avg_quality\": 0.8,\n    \"units\": [\n      {\n        \"bed\": 2,\n        \"bath\": 1,\n        \"name\": \"1A\",\n        \"sqft\": 1000,\n        \"price\": 1000\n      }\n    ]\n  }\n}"

response = http.request(request)
puts response.read_body
```

--------------------------------

### Retrieve Property Details via SDKs

Source: https://docs.hellodata.ai/api-reference/api-reference/property/get-property

Examples of how to perform a GET request to the property endpoint using different programming languages.

```python
import requests

url = "https://api.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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"
	"net/http"
	"io"
)

func main() {

	url := "https://api.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	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.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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.get("https://api.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4")
  .header("x-api-key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellodata.ai/property/0e628031-57b8-5394-821d-13779318fef4")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```

--------------------------------

### Update Metadata SDK Examples

Source: https://docs.hellodata.ai/api-reference/api-reference/property-report/update-metadata

Implementation examples for updating property metadata across various programming languages.

```python
import requests

url = "https://api.hellodata.ai/property_report/1.1/metadata"

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

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

print(response.json())
```

```javascript
const url = 'https://api.hellodata.ai/property_report/1.1/metadata';
const options = {
  method: 'PATCH',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{}'
};

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.hellodata.ai/property_report/1.1/metadata"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("PATCH", 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.hellodata.ai/property_report/1.1/metadata")

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

request = Net::HTTP::Patch.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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.patch("https://api.hellodata.ai/property_report/1.1/metadata")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.hellodata.ai/property_report/1.1/metadata', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hellodata.ai/property_report/1.1/metadata");
var request = new RestRequest(Method.PATCH);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellodata.ai/property_report/1.1/metadata")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()
```

--------------------------------

### Dataset Export SDK Examples

Source: https://docs.hellodata.ai/api-reference/api-reference/dataset/dataset-export-async

Implementation examples for the dataset export endpoint across multiple programming languages.

```python
import requests

url = "https://api.hellodata.ai/dataset/export"

payload = {
    "format": "csv",
    "name": "Monthly Rent Report",
    "webhookURL": "https://webhooks.example.com/dataset-export",
    "dataset": {
        "scopes": [{ "column": "lat" }, { "column": "lon" }, { "column": "asking_rent" }, { "column": "number_units" }],
        "filters": { "and": [None] }
    }
}
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.hellodata.ai/dataset/export';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"format":"csv","name":"Monthly Rent Report","webhookURL":"https://webhooks.example.com/dataset-export","dataset":{"scopes":[{"column":"lat"},{"column":"lon"},{"column":"asking_rent"},{"column":"number_units"}],"filters":{"and":[null]}}}'
};

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.hellodata.ai/dataset/export"

	payload := strings.NewReader("{\n  \"format\": \"csv\",\n  \"name\": \"Monthly Rent Report\",\n  \"webhookURL\": \"https://webhooks.example.com/dataset-export\",\n  \"dataset\": {\n    \"scopes\": [\n      {\n        \"column\": \"lat\"\n      },\n      {\n        \"column\": \"lon\"\n      },\n      {\n        \"column\": \"asking_rent\"\n      },\n      {\n        \"column\": \"number_units\"\n      }\n    ],\n    \"filters\": {\n      \"and\": [\n        null\n      ]\n    }\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.hellodata.ai/dataset/export")

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  \"format\": \"csv\",\n  \"name\": \"Monthly Rent Report\",\n  \"webhookURL\": \"https://webhooks.example.com/dataset-export\",\n  \"dataset\": {\n    \"scopes\": [\n      {\n        \"column\": \"lat\"\n      },\n      {\n        \"column\": \"lon\"\n      },\n      {\n        \"column\": \"asking_rent\"\n      },\n      {\n        \"column\": \"number_units\"\n      }\n    ],\n    \"filters\": {\n      \"and\": [\n        null\n      ]\n    }\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.hellodata.ai/dataset/export")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"format\": \"csv\",\n  \"name\": \"Monthly Rent Report\",\n  \"webhookURL\": \"https://webhooks.example.com/dataset-export\",\n  \"dataset\": {\n    \"scopes\": [\n      {\n        \"column\": \"lat\"\n      },\n      {\n        \"column\": \"lon\"\n      },\n      {\n        \"column\": \"asking_rent\"\n      },\n      {\n        \"column\": \"number_units\"\n      }\n    ],\n    \"filters\": {\n      \"and\": [\n        null\n      ]\n    }\n  }\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.hellodata.ai/dataset/export', [
  'body' => '{
  "format": "csv",
  "name": "Monthly Rent Report",
  "webhookURL": "https://webhooks.example.com/dataset-export",
  "dataset": {
    "scopes": [
      {
        "column": "lat"
      },
      {
        "column": "lon"
      },
      {
        "column": "asking_rent"
      },
      {
        "column": "number_units"
      }
    ],
    "filters": {
      "and": [
        null
      ]
    }
  }
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

--------------------------------

### Property Report Search SDK Examples

Source: https://docs.hellodata.ai/api-reference/api-reference/property-report/search

Implementation examples for querying the property report search endpoint across multiple programming languages.

```python
import requests

url = "https://api.hellodata.ai/property_report/search"

headers = {"x-api-key": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.hellodata.ai/property_report/search';
const options = {method: 'GET', headers: {'x-api-key': '<apiKey>'}};

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"
	"net/http"
	"io"
)

func main() {

	url := "https://api.hellodata.ai/property_report/search"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-api-key", "<apiKey>")

	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.hellodata.ai/property_report/search")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'

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.get("https://api.hellodata.ai/property_report/search")
  .header("x-api-key", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hellodata.ai/property_report/search', [
  'headers' => [
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hellodata.ai/property_report/search");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["x-api-key": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellodata.ai/property_report/search")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```

--------------------------------

### Query Pricing Recommendations via API

Source: https://docs.hellodata.ai/documentation/examples/price-recommendations

Basic examples for requesting pricing data using curl, Python, and JavaScript.

```bash
curl -X POST https://api.hellodata.ai/property/pricing \
     -H "x-api-key: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
      "subject": <PropertyPayload>,
     }
'

```

```python
import requests

url = "https://api.hellodata.ai/property/pricing"

payload = {
  "subject": <PropertyPayload>,
}

headers = {
  'x-api-key': '<your-api-key>',
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data = payload)
```

```javascript
const axios = require('axios')

const data = JSON.stringify({
  "subject": <PropertyPayload>,
})

const headers = {
  'x-api-key': '<your-api-key>',
  'Content-Type': 'application/json'
}

const config = {
  method: 'post',
  url,
  headers,
  data : data
}

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data))
  })
  .catch(function (error) {
    console.log(error)
  })
```

--------------------------------

### Market Search SDK Implementations

Source: https://docs.hellodata.ai/api-reference/api-reference/market/market-search

Code examples for performing a market search request across multiple programming languages.

```python
import requests

url = "https://api.hellodata.ai/market/search"

payload = { "coordinates": [[[[1.1]]]] }
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.hellodata.ai/market/search';
const options = {
  method: 'POST',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"coordinates":[[[[1.1]]]]}'
};

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.hellodata.ai/market/search"

	payload := strings.NewReader("{\n  \"coordinates\": [\n    [\n      [\n        [\n          1.1\n        ]\n      ]\n    ]\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.hellodata.ai/market/search")

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  \"coordinates\": [\n    [\n      [\n        [\n          1.1\n        ]\n      ]\n    ]\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.hellodata.ai/market/search")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"coordinates\": [\n    [\n      [\n        [\n          1.1\n        ]\n      ]\n    ]\n  ]\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.hellodata.ai/market/search', [
  'body' => '{
  "coordinates": [
    [
      [
        [
          1.1
        ]
      ]
    ]
  ]
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hellodata.ai/market/search");
var request = new RestRequest(Method.POST);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"coordinates\": [\n    [\n      [\n        [\n          1.1\n        ]\n      ]\n    ]\n  ]\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellodata.ai/market/search")! 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()
```

--------------------------------

### Trigger Dataset Export via cURL

Source: https://docs.hellodata.ai/documentation/examples/dataset-export

Command-line example to initiate a dataset export request.

```bash
     curl --location 'https://api.hellodata.ai/dataset/export' \
--header 'Content-Type: application/json' \
--header 'x-api-key: your-api-key' \
--data '{
    "dataset": {
        "scopes": [
            {"column": "street_address"},
            {"column": "asking_rent", "aggregate": "Avg"}
        ],
        "filters": [
            {"column": "msa", "filter": {"equals": "Seattle, WA"}},
            {"column": "bed", "filter": {"in": [1, 2, 3]}}
        ],
        "limit": 10000
    },
    "webhookURL": "https://yourapp.com/webhook/dataset-export",
    "name": "Seattle Rental Data Export",
    "format": "csv"
}'
```

--------------------------------

### Get Comparable Properties API Requests

Source: https://docs.hellodata.ai/documentation/examples/identify-comparables

Examples for querying the comparables endpoint using cURL, Python, and JavaScript. Ensure the <PropertyDetails> placeholder is replaced with data retrieved from the /property/{id} endpoint.

```bash
curl --location 'https://api.hellodata.ai/property/comparables' \
--header 'x-api-key: token' \
--header 'Content-Type: application/json' \
--data '{
  "subject": {
    <PropertyDetails>
  }
}'
```

```python
import requests

url = "https://api.hellodata.ai/property/comparables"

payload = {
  "subject": {
    <PropertyDetails> # get the details of the subject property using the /property/{id} endpoint
  }
}

headers = {
    'x-api-key': "token",
    'Content-Type': "application/json"
}

response = requests.request("POST", url, json=payload, headers=headers)

print(response.text)
```

```javascript
const axios = require('axios')

const config = {
    method: 'post',
    url: 'https://api.hellodata.ai/property/comparables',
    headers: { 
        'x-api-key': 'token', 
        'Content-Type': 'application/json'
    },
    data : {
        "subject": {
            <PropertyDetails> // feed the property details you retrieved from the /property/{id} endpoint
        }
    }
}

axios(config)
    .then((response) => {
        console.log(JSON.stringify(response.data))
    })
    .catch((error) => {
        console.log(error)
    })
```

--------------------------------

### Configure Pricing Recommendations with Settings

Source: https://docs.hellodata.ai/documentation/examples/price-recommendations

Advanced examples showing how to pass a settings object to refine comparable property search criteria.

```python
import requests

url = "https://api.hellodata.ai/property/pricing"

headers = {
  'x-api-key': '<your-api-key>',
  'Content-Type': 'application/json'
}

payload = {
  "subject": <PropertyPayload>,
  "settings": {
    "max_radius": 1, # 1 mile
    "listing_status": "closed", # closed units only
    "from_date": "2021-01-01", # closed between 2021-01-01 and 2021-12-31
    "to_date": "2021-12-31", 
    "include_outliers": false, # exclude outliers
    "building_ids": [], # go with recommended buildings (comparables)
    "excluded_unit_ids": ["3e628031-57b8-5394-821d-13779318fef4"], # But exclude this unit (a penthouse, for example)
    "exclude_subject": true # exclude the subject property from the comps, so that we don't compare it to itself
  }
}

response = requests.request("POST", url, headers=headers, data = payload)

print(response.json())
```

```javascript
const axios = require('axios')

const data = {
  "subject": <PropertyPayload>,
  "settings": {
    "max_radius": 1, // 1 mile
    "listing_status": "closed", // closed units only
    "from_date": "2021-01-01", // closed between 2021-01-01 and 2021-12-31
    "to_date": "2021-12-31", 
    "include_outliers": false, // exclude outliers
    "building_ids": [], // go with recommended buildings (comparables)
    "excluded_unit_ids": ["3e628031-57b8-5394-821d-13779318fef4"], // But exclude this unit (a penthouse, for example)
    "exclude_subject": true // exclude the subject property from the comps, so that we don't compare it to itself
  }
}

const headers = {
  'x-api-key': '<your-api-key>',
  'Content-Type': 'application/json'
}

const config = {
  method: 'post',
  url,
  headers,
  data
}

axios(config)
  .then(function (response) {
    console.log(JSON.stringify(response.data))
  })
  .catch(function (error) {
    console.log(error)
  })
```

--------------------------------

### OpenAPI Specification for Get Property

Source: https://docs.hellodata.ai/api-reference/api-reference/property/get-property

The OpenAPI definition for the /property/{id} GET endpoint, detailing the operation ID and summary.

```yaml
openapi: 3.1.0
info:
  title: backend
  version: 1.0.0
paths:
  /property/{id}:
    get:
      operationId: get-property
      summary: Get Property
      description: >-
        Retrieve all the details of a property given its id.


        - **ID changes**: it is rare, but can happen, to see the id of a
        property change. We consider it unlikely for bigger properties since
        they tend to have a more established "identity" among our data
        pipelines. For example, if multiples properties are merged into one, or
        major data changes make us change the id. In this case, you might
        receive a 404 error. The property search endpoint is free, so always
        feel free to query it in case that happens.

        - **Payload usage**: this payload can be used to get the property
        details, the unit pricing, the expense benchmarks, and the rent comps.
        And you are free to cache it if you need to.

        - **Date filtering**: You can optionally filter units, history,
        availability periods, and concessions by providing `from` and/or `to`
        date parameters. Only data that overlaps with the specified date range
        will be included. You can provide either date, both, or neither. This is
        particularly useful when you only need current or recent data, as it can
        significantly speed up API calls and reduce response payload size
        compared to retrieving the full historical dataset.


        We make a few properties free to access to help with testing. These
        three properties are listed below but if you would like to use a
        different property to test with, we are happy to allow that for you.


        | ID                                   | Building Name        |
        Address                                       |

        |--------------------------------------|----------------------|-----------------------------------------------|

        | e8769b06-1334-5ab6-b9c6-6dfccbf9ea78 | Reserve at Glenview  | 195
        Waukegan Road, Glenview, IL 60025         |

        | 20e4945a-ce78-5f2c-9053-6bdaca39044b | 7229-33 S Yates Blvd | 7229
        South Yates Boulevard, Chicago, IL 60649 |
```

--------------------------------

### Market Shape Search SDK Implementations

Source: https://docs.hellodata.ai/api-reference/api-reference/market/shape-search

Examples for querying the market shape search endpoint using various programming languages. Replace <apiKey> with your actual API key.

```python
import requests

url = "https://api.hellodata.ai/market/shape_search"

querystring = {"q":"farmers market seattle"}

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

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())
```

```javascript
const url = 'https://api.hellodata.ai/market/shape_search?q=farmers+market+seattle';
const options = {
  method: 'GET',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{}'
};

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.hellodata.ai/market/shape_search?q=farmers+market+seattle"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("GET", 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.hellodata.ai/market/shape_search?q=farmers+market+seattle")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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.get("https://api.hellodata.ai/market/shape_search?q=farmers+market+seattle")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hellodata.ai/market/shape_search?q=farmers+market+seattle', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hellodata.ai/market/shape_search?q=farmers+market+seattle");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellodata.ai/market/shape_search?q=farmers+market+seattle")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
```

--------------------------------

### GET /property_report/list

Source: https://docs.hellodata.ai/api-reference

Retrieves a list of property reports.

```APIDOC
## GET /property_report/list

### Description
Retrieves a list of property reports available in the system.

### Method
GET

### Endpoint
https://api.hellodata.ai/property_report/list

### Parameters
#### Headers
- **x-api-key** (string) - Required - API authentication key.
- **Content-Type** (string) - Required - Must be set to application/json.

### Request Example
{}

### Response
#### Success Response (200)
- **data** (array) - List of property report objects.
```

--------------------------------

### List Property Reports via SDK

Source: https://docs.hellodata.ai/api-reference

Examples for fetching property report data from the HelloData API endpoint using different programming languages.

```python
import requests

url = "https://api.hellodata.ai/property_report/list"

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

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

print(response.json())
```

```javascript
const url = 'https://api.hellodata.ai/property_report/list';
const options = {
  method: 'GET',
  headers: {'x-api-key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{}'
};

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.hellodata.ai/property_report/list"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("GET", 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.hellodata.ai/property_report/list")

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

request = Net::HTTP::Get.new(url)
request["x-api-key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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.get("https://api.hellodata.ai/property_report/list")
  .header("x-api-key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hellodata.ai/property_report/list', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
    'x-api-key' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hellodata.ai/property_report/list");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hellodata.ai/property_report/list")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()
```

--------------------------------

### GET /property_report/list

Source: https://docs.hellodata.ai/api-reference/api-reference/property-report/list

Retrieves a list of available property reports.

```APIDOC
## GET /property_report/list

### Description
Retrieves a list of property reports.

### Method
GET

### Endpoint
https://api.hellodata.ai/property_report/list

### Request Headers
- **x-api-key** (string) - Required - The API key for authentication.
- **Content-Type** (string) - Required - Should be set to application/json.

### Request Body
- Empty object ({})

### Response
#### Success Response (200)
- Returns a list of property report objects.
```
Tokens:
Raw