> This page is for Developer.

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

# Get imports for DB

GET https://meta.feedonomics.com/api.php/dbs/{db_id}/imports

Reference: https://docs.feedonomics.com/developer/api-reference/rest/platform-api/imports/get-imports-for-db

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `db_id` (double, required)

### Headers

- `x-api-key` (string, required)

## Response

### 200

Get imports for DB

- `list of DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItems`

## Types

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItems

- `id` (string, optional)
- `db_id` (string, optional)
- `name` (string, optional)
- `cron` (string, optional)
- `next_run_time` (string, optional)
- `status` (string, optional)
- `file_location` (string, optional)
- `import_info` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfo, optional)
- `file_type` (string, optional)
- `file_map` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsFileMap, optional)
- `line_terminator` (string, optional)
- `join_type` (string, optional)
- `running` (string, optional)
- `cxn_id` (string, optional)
- `name_based_maps` (string, optional)
- `xml_force_parse` (string, optional)
- `force_encoding` (string, optional)
- `timestamp` (string, optional)
- `ignore_lines` (string, optional)
- `load_threshold` (string, optional)
- `update_threshold` (string, optional)
- `max_attempts` (string, optional)
- `time_between_attempts` (string, optional)
- `limits` (string, optional)
- `backup_cxn_id` (string, optional)
- `last_download_time` (string, optional)
- `last_backup_time` (string, optional)
- `needs_backup` (string, optional)
- `xmlreader` (string, optional)
- `clean_file_headers` (string, optional)
- `download_activity_timeout` (string, optional)
- `timeout` (string, optional)
- `last_download_status` (string, optional)
- `backup_failures` (string, optional)
- `ftp_allow_minio_direct` (string, optional)
- `created_at` (string, optional)
- `last_download_size` (string, optional)
- `last_run_duration` (string, optional)
- `load_threshold_percent` (string, optional)
- `stats` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsStats, optional)
- `tags` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsTags, optional)

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfo

- `url` (string, optional)
- `CURLOPT_USERAGENT` (string, optional)
- `preprocess_info` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfoPreprocessInfo, optional)

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsFileMap

- `encoding` (string, optional)
- `separator` (string, optional)
- `enclosure` (string, optional)
- `escaper` (string, optional)
- `maps` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsFileMapMaps, optional)

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsStats

- `rows_loaded` (string, optional)
- `rows_updated` (integer, optional)

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsTags

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfoPreprocessInfo

- `connection_info` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfoPreprocessInfoConnectionInfo, optional)
- `file_info` (DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfoPreprocessInfoFileInfo, optional)

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsFileMapMaps

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfoPreprocessInfoConnectionInfo

- `client` (string, optional)
- `oauth_token` (string, optional)
- `protocol` (string, optional)
- `shop_name` (string, optional)

### DbsDbIdImportsGetResponsesContentApplicationJsonSchemaItemsImportInfoPreprocessInfoFileInfo

- `request_type` (string, optional)

## Examples

**Response**

```json
[
  {
    "id": "1",
    "db_id": "1",
    "name": "import one",
    "status": "0",
    "file_location": "local",
    "file_type": "delimited",
    "file_map": {
      "encoding": "",
      "separator": ",",
      "enclosure": "",
      "escaper": "",
      "maps": {
        "id": "id",
        "image_link": "image_link",
        "row": "row",
        "tags": "tags"
      }
    },
    "join_type": "product_feed",
    "running": "0",
    "cxn_id": "0",
    "name_based_maps": "1",
    "xml_force_parse": "0",
    "force_encoding": "0",
    "timestamp": "0000-00-00 00:00:00",
    "ignore_lines": "1",
    "load_threshold": "1",
    "update_threshold": "1",
    "max_attempts": "1",
    "time_between_attempts": "1",
    "limits": "",
    "last_download_time": "2021-09-16 17:48:07",
    "last_backup_time": "0000-00-00 00:00:00",
    "needs_backup": "1",
    "xmlreader": "0",
    "clean_file_headers": "0",
    "download_activity_timeout": "0",
    "timeout": "900",
    "last_download_status": "",
    "backup_failures": "0",
    "ftp_allow_minio_direct": "0",
    "created_at": "2021-09-16 17:48:06",
    "tags": {
      "platform": "Not Applicable"
    }
  }
]
```

**SDK Code**

```python Imports_getImportsForDb_example
import requests

url = "https://meta.feedonomics.com/api.php/dbs/1.1/imports"

headers = {
    "x-api-key": "x-api-key",
    "Authorization": "Bearer <token>"
}

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

print(response.json())
```

```javascript Imports_getImportsForDb_example
const url = 'https://meta.feedonomics.com/api.php/dbs/1.1/imports';
const options = {
  method: 'GET',
  headers: {'x-api-key': 'x-api-key', Authorization: 'Bearer <token>'}
};

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

```go Imports_getImportsForDb_example
package main

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

func main() {

	url := "https://meta.feedonomics.com/api.php/dbs/1.1/imports"

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

	req.Header.Add("x-api-key", "x-api-key")
	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 Imports_getImportsForDb_example
require 'uri'
require 'net/http'

url = URI("https://meta.feedonomics.com/api.php/dbs/1.1/imports")

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

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

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

```java Imports_getImportsForDb_example
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://meta.feedonomics.com/api.php/dbs/1.1/imports")
  .header("x-api-key", "x-api-key")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://meta.feedonomics.com/api.php/dbs/1.1/imports', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'x-api-key' => 'x-api-key',
  ],
]);

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

```csharp Imports_getImportsForDb_example
using RestSharp;

var client = new RestClient("https://meta.feedonomics.com/api.php/dbs/1.1/imports");
var request = new RestRequest(Method.GET);
request.AddHeader("x-api-key", "x-api-key");
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Imports_getImportsForDb_example
import Foundation

let headers = [
  "x-api-key": "x-api-key",
  "Authorization": "Bearer <token>"
]

let request = NSMutableURLRequest(url: NSURL(string: "https://meta.feedonomics.com/api.php/dbs/1.1/imports")! 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()
```