> 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.

# Source storage

Storage connectors let Umnai read source data from an Amazon S3 bucket during ingestion.

A connector points to a bucket in your AWS account. Ingestion jobs use the connector together with a data path, schema, ingestion configuration, and compute configuration to create or update datasources.

Source storage and account storage have different roles. A source connector only requires read access to the files you want to ingest. Account storage contains platform-created resources and requires broader permissions.

Both roles can use the same S3 bucket, but dedicated buckets are strongly recommended to keep source files and platform-created resources isolated. See [Account storage](/guides/setup/account-storage) for account-storage options and permissions.

## Grant read-only access

For a bucket used only as source storage, grant Umnai read-only access.

The platform only needs permission to list bucket contents and read objects. If you reuse a provided account-storage bucket, it already requires broader permissions; confirm its policy with Umnai support rather than replacing it with this read-only policy.

1. In the AWS Console, open **S3**. Ensure that the selected AWS Region matches the region agreed with Umnai during onboarding.

2. Select the bucket that contains your source data and open the **Permissions** tab.

3. Under **Bucket policy**, select **Edit**, then paste the following policy.

4. Obtain the Umnai platform AWS account ID for your environment from Umnai support.

5. Replace `<ACCOUNT-ID>` with the account ID provided to you and `<YOUR-BUCKET-NAME>` with your bucket's name:

   ```json
   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowSourceObjectRead",
         "Effect": "Allow",
         "Principal": {
           "AWS": "arn:aws:iam::<ACCOUNT-ID>:root"
         },
         "Action": [
           "s3:GetObject"
         ],
         "Resource": "arn:aws:s3:::<YOUR-BUCKET-NAME>/*"
       },
       {
         "Sid": "AllowSourceBucketList",
         "Effect": "Allow",
         "Principal": {
           "AWS": "arn:aws:iam::<ACCOUNT-ID>:root"
         },
         "Action": [
           "s3:ListBucket"
         ],
         "Resource": "arn:aws:s3:::<YOUR-BUCKET-NAME>"
       }
     ]
   }
   ```

6. Select **Save changes**. You should see confirmation that the bucket policy was updated.

## Create a storage connector

Create a storage connector after the bucket policy is in place.

### Request

POST [https://api.hi.umnai.com/storage-connectors](https://api.hi.umnai.com/storage-connectors)

**`Create storage connector`**

```curl Create storage connector
curl -X POST https://api.hi.umnai.com/storage-connectors \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "bucket_name": "sample-storage-connector-bucket",
  "name": "Sample Storage Connector"
}'
```

**`Create storage connector`**

```python Create storage connector
import requests

url = "https://api.hi.umnai.com/storage-connectors"

payload = {
    "bucket_name": "sample-storage-connector-bucket",
    "name": "Sample Storage Connector"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

**`Create storage connector`**

```javascript Create storage connector
const url = 'https://api.hi.umnai.com/storage-connectors';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"bucket_name":"sample-storage-connector-bucket","name":"Sample Storage Connector"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

**`Create storage connector`**

```go Create storage connector
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.hi.umnai.com/storage-connectors"

	payload := strings.NewReader("{\n  \"bucket_name\": \"sample-storage-connector-bucket\",\n  \"name\": \"Sample Storage Connector\"\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))

}
```

**`Create storage connector`**

```ruby Create storage connector
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/storage-connectors")

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  \"bucket_name\": \"sample-storage-connector-bucket\",\n  \"name\": \"Sample Storage Connector\"\n}"

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

**`Create storage connector`**

```java Create storage connector
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api.hi.umnai.com/storage-connectors")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"bucket_name\": \"sample-storage-connector-bucket\",\n  \"name\": \"Sample Storage Connector\"\n}")
  .asString();
```

**`Create storage connector`**

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.hi.umnai.com/storage-connectors', [
  'body' => '{
  "bucket_name": "sample-storage-connector-bucket",
  "name": "Sample Storage Connector"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

**`Create storage connector`**

```csharp Create storage connector
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/storage-connectors");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"bucket_name\": \"sample-storage-connector-bucket\",\n  \"name\": \"Sample Storage Connector\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

**`Create storage connector`**

```swift Create storage connector
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "bucket_name": "sample-storage-connector-bucket",
  "name": "Sample Storage Connector"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/storage-connectors")! 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": "02910f90b30a5b94ad505efe83280dca",
  "name": "Sample Storage Connector",
  "bucket_name": "sample-storage-connector-bucket",
  "account": {
    "id": "e268443e43d93dab7ebef303bbe9642f",
    "name": "Sample Account"
  },
  "created_at": "2026-03-12T13:55:14.315928Z",
  "created_by": {
    "id": "dad46b2058752ffde5eaf02f1eb6abd5",
    "name": "Sample User"
  }
}
```

Save the returned connector `id`. You will use it when retrieving an inferred schema and when creating ingestion jobs.

## Retrieve storage connectors

Retrieve storage connectors when you need to reuse an existing connector.

### Request

GET [https://api.hi.umnai.com/storage-connectors](https://api.hi.umnai.com/storage-connectors)

**`Retrieve storage connectors`**

```curl Retrieve storage connectors
curl https://api.hi.umnai.com/storage-connectors \
     -H "Authorization: Bearer <token>"
```

**`Retrieve storage connectors`**

```python Retrieve storage connectors
import requests

url = "https://api.hi.umnai.com/storage-connectors"

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

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

print(response.json())
```

**`Retrieve storage connectors`**

```javascript Retrieve storage connectors
const url = 'https://api.hi.umnai.com/storage-connectors';
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);
}
```

**`Retrieve storage connectors`**

```go Retrieve storage connectors
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.hi.umnai.com/storage-connectors"

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

}
```

**`Retrieve storage connectors`**

```ruby Retrieve storage connectors
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/storage-connectors")

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

**`Retrieve storage connectors`**

```java Retrieve storage connectors
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.hi.umnai.com/storage-connectors")
  .header("Authorization", "Bearer <token>")
  .asString();
```

**`Retrieve storage connectors`**

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

$client = new \GuzzleHttp\Client();

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

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

**`Retrieve storage connectors`**

```csharp Retrieve storage connectors
using RestSharp;

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

**`Retrieve storage connectors`**

```swift Retrieve storage connectors
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/storage-connectors")! 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": "c8d98a209dbe25e77ed54e7e12b4fd37",
      "name": "Sample Storage Connector",
      "bucket_name": "sample-storage-connector-bucket",
      "account": {
        "id": "729c654903c0aee752e82c44d02f5918",
        "name": "Sample Account"
      },
      "created_at": "2026-03-12T13:55:14.315928Z",
      "created_by": {
        "id": "eca422469dc3270625bf646df3472a45",
        "name": "Sample User"
      }
    }
  ],
  "pagination": {
    "total_items": 1,
    "items_per_page": 100,
    "current_page": 1,
    "total_pages": 1
  }
}
```

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

### Request

GET [https://api.hi.umnai.com/storage-connectors/\{storageConnectorId}](https://api.hi.umnai.com/storage-connectors/\{storageConnectorId})

**`Retrieve storage connector`**

```curl Retrieve storage connector
curl https://api.hi.umnai.com/storage-connectors/storageConnectorId \
     -H "Authorization: Bearer <token>"
```

**`Retrieve storage connector`**

```python Retrieve storage connector
import requests

url = "https://api.hi.umnai.com/storage-connectors/storageConnectorId"

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

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

print(response.json())
```

**`Retrieve storage connector`**

```javascript Retrieve storage connector
const url = 'https://api.hi.umnai.com/storage-connectors/storageConnectorId';
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);
}
```

**`Retrieve storage connector`**

```go Retrieve storage connector
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.hi.umnai.com/storage-connectors/storageConnectorId"

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

}
```

**`Retrieve storage connector`**

```ruby Retrieve storage connector
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/storage-connectors/storageConnectorId")

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

**`Retrieve storage connector`**

```java Retrieve storage connector
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.hi.umnai.com/storage-connectors/storageConnectorId")
  .header("Authorization", "Bearer <token>")
  .asString();
```

**`Retrieve storage connector`**

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

$client = new \GuzzleHttp\Client();

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

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

**`Retrieve storage connector`**

```csharp Retrieve storage connector
using RestSharp;

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

**`Retrieve storage connector`**

```swift Retrieve storage connector
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/storage-connectors/storageConnectorId")! 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
{
  "id": "02910f90b30a5b94ad505efe83280dca",
  "name": "Sample Storage Connector",
  "bucket_name": "sample-storage-connector-bucket",
  "account": {
    "id": "e268443e43d93dab7ebef303bbe9642f",
    "name": "Sample Account"
  },
  "created_at": "2026-03-12T13:55:14.315928Z",
  "created_by": {
    "id": "dad46b2058752ffde5eaf02f1eb6abd5",
    "name": "Sample User"
  }
}
```

## Update a storage connector

Update a storage connector when you need to rename it.

### Request

PATCH [https://api.hi.umnai.com/storage-connectors/\{storageConnectorId}](https://api.hi.umnai.com/storage-connectors/\{storageConnectorId})

**`Update storage connector`**

```curl Update storage connector
curl -X PATCH https://api.hi.umnai.com/storage-connectors/storageConnectorId \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "name": "Sample Storage Connector"
}'
```

**`Update storage connector`**

```python Update storage connector
import requests

url = "https://api.hi.umnai.com/storage-connectors/storageConnectorId"

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

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

print(response.json())
```

**`Update storage connector`**

```javascript Update storage connector
const url = 'https://api.hi.umnai.com/storage-connectors/storageConnectorId';
const options = {
  method: 'PATCH',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"name":"Sample Storage Connector"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

**`Update storage connector`**

```go Update storage connector
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.hi.umnai.com/storage-connectors/storageConnectorId"

	payload := strings.NewReader("{\n  \"name\": \"Sample Storage Connector\"\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))

}
```

**`Update storage connector`**

```ruby Update storage connector
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/storage-connectors/storageConnectorId")

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 Storage Connector\"\n}"

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

**`Update storage connector`**

```java Update storage connector
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.patch("https://api.hi.umnai.com/storage-connectors/storageConnectorId")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"name\": \"Sample Storage Connector\"\n}")
  .asString();
```

**`Update storage connector`**

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

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.hi.umnai.com/storage-connectors/storageConnectorId', [
  'body' => '{
  "name": "Sample Storage Connector"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

**`Update storage connector`**

```csharp Update storage connector
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/storage-connectors/storageConnectorId");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"Sample Storage Connector\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

**`Update storage connector`**

```swift Update storage connector
import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/storage-connectors/storageConnectorId")! 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": "02910f90b30a5b94ad505efe83280dca",
  "name": "Sample Storage Connector",
  "bucket_name": "sample-storage-connector-bucket",
  "account": {
    "id": "e268443e43d93dab7ebef303bbe9642f",
    "name": "Sample Account"
  },
  "created_at": "2026-03-12T13:55:14.315928Z",
  "created_by": {
    "id": "dad46b2058752ffde5eaf02f1eb6abd5",
    "name": "Sample User"
  },
  "updated_at": "2026-03-12T13:55:14.231528Z"
}
```

## Retrieve an inferred schema

After creating a connector, you can retrieve an inferred data schema from a path inside the bucket.

Use this when you want Umnai to inspect source data and suggest the schema to refine before ingestion.

### Request

GET [https://api.hi.umnai.com/storage-connectors/\{storageConnectorId}/schema](https://api.hi.umnai.com/storage-connectors/\{storageConnectorId}/schema)

**`Retrieve data schema`**

```curl Retrieve data schema
curl -G https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema \
     -H "Authorization: Bearer <token>" \
     -d path=path
```

**`Retrieve data schema`**

```python Retrieve data schema
import requests

url = "https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema"

querystring = {"path":"path"}

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

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

print(response.json())
```

**`Retrieve data schema`**

```javascript Retrieve data schema
const url = 'https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema?path=path';
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);
}
```

**`Retrieve data schema`**

```go Retrieve data schema
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema?path=path"

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

}
```

**`Retrieve data schema`**

```ruby Retrieve data schema
require 'uri'
require 'net/http'

url = URI("https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema?path=path")

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

**`Retrieve data schema`**

```java Retrieve data schema
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema?path=path")
  .header("Authorization", "Bearer <token>")
  .asString();
```

**`Retrieve data schema`**

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema?path=path', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

**`Retrieve data schema`**

```csharp Retrieve data schema
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema?path=path");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

**`Retrieve data schema`**

```swift Retrieve data schema
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.hi.umnai.com/storage-connectors/storageConnectorId/schema?path=path")! 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
{
  "fields": [
    {
      "data_type": {
        "data_type": "NUMBER",
        "format": "INT64"
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CONTINUOUS",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "NUMBER",
        "format": "INT64"
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CONTINUOUS",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "NUMBER",
        "format": "INT64"
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CONTINUOUS",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "NUMBER",
        "format": "INT64"
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CONTINUOUS",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "STRING",
        "format": null
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CATEGORICAL",
      "vector": false
    },
    {
      "data_type": {
        "data_type": "NUMBER",
        "format": "INT64"
      },
      "designation": "FEATURE",
      "name": "Sample Field",
      "semantic_type": "CONTINUOUS",
      "vector": false
    }
  ]
}
```

## Delete a storage connector

Delete a storage connector when it should no longer be used for ingestion.

### Request

DELETE [https://api.hi.umnai.com/storage-connectors/\{storageConnectorId}](https://api.hi.umnai.com/storage-connectors/\{storageConnectorId})

```curl
curl -X DELETE https://api.hi.umnai.com/storage-connectors/storageConnectorId \
     -H "Authorization: Bearer <token>"
```

```python
import requests

url = "https://api.hi.umnai.com/storage-connectors/storageConnectorId"

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

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

print(response.json())
```

```javascript
const url = 'https://api.hi.umnai.com/storage-connectors/storageConnectorId';
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/storage-connectors/storageConnectorId"

	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/storage-connectors/storageConnectorId")

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/storage-connectors/storageConnectorId")
  .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/storage-connectors/storageConnectorId', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.hi.umnai.com/storage-connectors/storageConnectorId");
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/storage-connectors/storageConnectorId")! 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()
```

Deleting a storage connector does not change your S3 bucket policy. If you also want to revoke bucket access, remove the corresponding S3 bucket policy statement in AWS.