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

# Configuration

An ingestion configuration defines how source data is interpreted during ingestion.

It references the data schema used to validate the source columns. Ingestion jobs then reuse the configuration when creating or updating datasources.

## Create a configuration

Create an ingestion configuration after you have created or selected a data schema.

### Request

POST [https://api.hi.umnai.com/data-processing-ingestion-configurations](https://api.hi.umnai.com/data-processing-ingestion-configurations)

```curl
curl -X POST https://api.hi.umnai.com/data-processing-ingestion-configurations \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "name": "Sample Ingestion Configuration",
  "data_schema_id": "c1342ae9bd985c0d9c5fa5222609c3fa"
}'
```

```python
import requests

url = "https://api.hi.umnai.com/data-processing-ingestion-configurations"

payload = {
    "name": "Sample Ingestion Configuration",
    "data_schema_id": "c1342ae9bd985c0d9c5fa5222609c3fa"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api.hi.umnai.com/data-processing-ingestion-configurations';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"name":"Sample Ingestion Configuration","data_schema_id":"c1342ae9bd985c0d9c5fa5222609c3fa"}'
};

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.hi.umnai.com/data-processing-ingestion-configurations"

	payload := strings.NewReader("{\n  \"name\": \"Sample Ingestion Configuration\",\n  \"data_schema_id\": \"c1342ae9bd985c0d9c5fa5222609c3fa\"\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	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.hi.umnai.com/data-processing-ingestion-configurations")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Sample Ingestion Configuration\",\n  \"data_schema_id\": \"c1342ae9bd985c0d9c5fa5222609c3fa\"\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.hi.umnai.com/data-processing-ingestion-configurations")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Sample Ingestion Configuration\",\n  \"data_schema_id\": \"c1342ae9bd985c0d9c5fa5222609c3fa\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.hi.umnai.com/data-processing-ingestion-configurations', [
  'body' => '{
  "name": "Sample Ingestion Configuration",
  "data_schema_id": "c1342ae9bd985c0d9c5fa5222609c3fa"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/data-processing-ingestion-configurations");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Sample Ingestion Configuration\",\n  \"data_schema_id\": \"c1342ae9bd985c0d9c5fa5222609c3fa\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "name": "Sample Ingestion Configuration",
  "data_schema_id": "c1342ae9bd985c0d9c5fa5222609c3fa"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/data-processing-ingestion-configurations")! 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()
```

### Response (201)

```json
{
  "id": "d2f74730b1467213748b3750b3ad87ac",
  "name": "Sample Ingestion Configuration",
  "account": {
    "id": "e268443e43d93dab7ebef303bbe9642f",
    "name": "Sample Account"
  },
  "created_at": "2026-03-15T10:15:30.000000Z",
  "observation_specification": {
    "observation_type": "observation_type",
    "observation_source": "observation_source",
    "observation_shard_id": "observation_shard_id",
    "observation_file_index": "observation_file_index",
    "observation_index": "observation_index",
    "observation_mask_index": "observation_mask_index",
    "observation_mask_file_index": "observation_mask_file_index",
    "observation_increment_index": "observation_increment_index"
  },
  "created_by": {
    "id": "dad46b2058752ffde5eaf02f1eb6abd5",
    "name": "Sample User"
  },
  "updated_at": "2026-03-15T10:15:30.000000Z",
  "data_schema": {
    "id": "c1342ae9bd985c0d9c5fa5222609c3fa",
    "name": "Sample Data Schema"
  }
}
```

Save the returned configuration `id`. You will use it when starting ingestion jobs.

## Observation fields

During ingestion, the platform can add observation fields that help identify, track, and process rows.

By default, these fields use standard names such as `observation_type`, `observation_source`, and `observation_increment_index`. You only need to configure `observation_specification` when your source data already uses different column names for these concepts.

### Training and test rows

If your source data includes a column that separates training rows from test rows, map that column through `observation_specification.observation_type`.

If no observation type is provided, ingested rows are treated as training data.

## Retrieve configurations

Retrieve ingestion configurations when you need to reuse an existing configuration.

### Request

GET [https://api.hi.umnai.com/data-processing-ingestion-configurations](https://api.hi.umnai.com/data-processing-ingestion-configurations)

```curl
curl https://api.hi.umnai.com/data-processing-ingestion-configurations \
     -H "Authorization: Bearer <token>"
```

```python
import requests

url = "https://api.hi.umnai.com/data-processing-ingestion-configurations"

headers = {"Authorization": "Bearer <token>"}

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

print(response.json())
```

```javascript
const url = 'https://api.hi.umnai.com/data-processing-ingestion-configurations';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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.hi.umnai.com/data-processing-ingestion-configurations"

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

	req.Header.Add("Authorization", "Bearer <token>")

	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.hi.umnai.com/data-processing-ingestion-configurations")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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.hi.umnai.com/data-processing-ingestion-configurations")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hi.umnai.com/data-processing-ingestion-configurations', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/data-processing-ingestion-configurations");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/data-processing-ingestion-configurations")! 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()
```

### Response (200)

```json
{
  "data": [
    {
      "id": "ea8b745ead39ec442fc3b4fba359bf98",
      "name": "Sample Organisation",
      "created_at": "2026-03-11T16:04:19.749000Z",
      "updated_at": null,
      "status": "ACTIVE"
    }
  ],
  "pagination": {
    "total_items": 1,
    "items_per_page": 10,
    "current_page": 1,
    "total_pages": 1
  }
}
```

To inspect a specific configuration, retrieve it by `id`.

### Request

GET [https://api.hi.umnai.com/data-processing-ingestion-configurations/\{dataProcessingIngestionConfigurationId}](https://api.hi.umnai.com/data-processing-ingestion-configurations/\{dataProcessingIngestionConfigurationId})

```curl
curl https://api.hi.umnai.com/data-processing-ingestion-configurations/{dataProcessingIngestionConfigurationId} \
     -H "Authorization: Bearer <token>"
```

```python
import requests

url = "https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId"

headers = {"Authorization": "Bearer <token>"}

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

print(response.json())
```

```javascript
const url = 'https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId"

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

	req.Header.Add("Authorization", "Bearer <token>")

	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.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId")! 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()
```

### Response (200)

```json
{
  "data": [
    {
      "id": "ea8b745ead39ec442fc3b4fba359bf98",
      "name": "Sample Organisation",
      "status": "ACTIVE",
      "created_at": "2026-03-11T16:04:19.749000Z",
      "updated_at": null
    }
  ],
  "pagination": {
    "total_items": 1,
    "items_per_page": 10,
    "current_page": 1,
    "total_pages": 1
  }
}
```

## Update a configuration

Update an ingestion configuration when you need to rename it or point it to a different data schema.

### Request

PATCH [https://api.hi.umnai.com/data-processing-ingestion-configurations/\{dataProcessingIngestionConfigurationId}](https://api.hi.umnai.com/data-processing-ingestion-configurations/\{dataProcessingIngestionConfigurationId})

```curl
curl -X PATCH https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "name": "Sample Ingestion Configuration"
}'
```

```python
import requests

url = "https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId"

payload = { "name": "Sample Ingestion Configuration" }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"name":"Sample Ingestion Configuration"}'
};

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.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId"

	payload := strings.NewReader("{\n  \"name\": \"Sample Ingestion Configuration\"\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	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.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId")

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

request = Net::HTTP::Patch.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"name\": \"Sample Ingestion Configuration\"\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.patch("https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Sample Ingestion Configuration\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId', [
  'body' => '{
  "name": "Sample Ingestion Configuration"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Sample Ingestion Configuration\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["name": "Sample Ingestion Configuration"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/data-processing-ingestion-configurations/:dataProcessingIngestionConfigurationId")! 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()
```

### Response (200)

```json
{
  "id": "d2f74730b1467213748b3750b3ad87ac",
  "name": "Sample Ingestion Configuration",
  "account": {
    "id": "e268443e43d93dab7ebef303bbe9642f",
    "name": "Sample Account"
  },
  "created_at": "2026-03-15T10:15:30.000000Z",
  "observation_specification": {
    "observation_type": "observation_type",
    "observation_source": "observation_source",
    "observation_shard_id": "9d1d3ae7d37a564b88b9eef14e005c2b",
    "observation_file_index": "observation_file_index",
    "observation_index": "observation_index",
    "observation_mask_index": "observation_mask_index",
    "observation_mask_file_index": "observation_mask_file_index",
    "observation_increment_index": "observation_increment_index"
  },
  "created_by": {
    "id": "dad46b2058752ffde5eaf02f1eb6abd5",
    "name": "Sample User"
  },
  "updated_at": "2026-03-15T10:15:30.000000Z",
  "data_schema": {
    "id": "c1342ae9bd985c0d9c5fa5222609c3fa",
    "name": "Sample Data Schema"
  }
}
```

Schema changes apply to future ingestion jobs that use the configuration. Existing datasources keep the schema that was applied when they were ingested.

## Delete a configuration

Delete an ingestion configuration when it should no longer be used by future ingestion jobs.

### Request

DELETE [https://api.hi.umnai.com/data-processing-ingestion-configurations/\{dataProcessingIngestionConfigurationId}](https://api.hi.umnai.com/data-processing-ingestion-configurations/\{dataProcessingIngestionConfigurationId})

```curl
curl -X DELETE https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId \
     -H "Authorization: Bearer <token>"
```

```python
import requests

url = "https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId"

headers = {"Authorization": "Bearer <token>"}

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

print(response.json())
```

```javascript
const url = 'https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId';
const options = {method: 'DELETE', headers: {Authorization: 'Bearer <token>'}};

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.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId"

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

	req.Header.Add("Authorization", "Bearer <token>")

	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.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId")

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

request = Net::HTTP::Delete.new(url)
request["Authorization"] = 'Bearer <token>'

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.delete("https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('DELETE', 'https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId");
var request = new RestRequest(Method.DELETE);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/data-processing-ingestion-configurations/dataProcessingIngestionConfigurationId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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()
```