lilt.ConnectorsApi

All URIs are relative to https://lilt.com/2

Method	HTTP request	Description
create_connector	POST /connectors	Upload a Connector
delete_connector	DELETE /connectors	Delete a Connector
export_connector_job	POST /connectors/jobs/deliver	Deliver a Connector Job
get_connector_jobs	GET /connectors/jobs	Retrieve a Connector Job
get_connectors	GET /connectors	Retrieve a Connector
sync_connector	POST /connectors/sync	Sync a Connector
update_connector	PUT /connectors	Upload a Connector

create_connector

Connector create_connector(body)

Upload a Connector

Create a new connector linked to a supported external cms.

Example

• Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) body = lilt.Connector() # Connector |

try:
    # Upload a Connector
    api_response = api_instance.create_connector(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->create_connector: %s\n" % e) ```

• Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) body = lilt.Connector() # Connector |

try:
    # Upload a Connector
    api_response = api_instance.create_connector(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->create_connector: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
body	Connector

Return type

Connector

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 201 | A Connector object. | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

delete_connector

ConnectorDeleteResponse delete_connector(id)

Delete a Connector

Delete a Connector. Example CURL command: curl -X DELETE https://lilt.com/2/connectors?key=API_KEY&id=123

Example

• Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector identifier.

try:
    # Delete a Connector
    api_response = api_instance.delete_connector(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->delete_connector: %s\n" % e) ```

• Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector identifier.

try:
    # Delete a Connector
    api_response = api_instance.delete_connector(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->delete_connector: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
id	int	A unique Connector identifier.

Return type

ConnectorDeleteResponse

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 204 | A status object. | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

export_connector_job

export_connector_job(id)

Deliver a Connector Job

Request an export job for the given connector job ID. This will check Lilt for completed projects that are associated with this job and deliver them to the target system. Example CURL command: curl -X POST https://lilt.com/2/connectors/jobs/deliver?key=API_KEY&id=9274

Example

• Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector Job identifier.

try:
    # Deliver a Connector Job
    api_instance.export_connector_job(id)
except ApiException as e:
    print("Exception when calling ConnectorsApi->export_connector_job: %s\n" % e) ```

• Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector Job identifier.

try:
    # Deliver a Connector Job
    api_instance.export_connector_job(id)
except ApiException as e:
    print("Exception when calling ConnectorsApi->export_connector_job: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
id	int	A unique Connector Job identifier.

Return type

void (empty response body)

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | A success status code. | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_connector_jobs

list[ConnectorJob] get_connector_jobs(id)

Retrieve a Connector Job

Retrieves a connector job available to your user. Use this to check the status of jobs started by the /connectors/sync and /connectors/jobs/deliver endpoints. Example CURL command: curl -X GET https://lilt.com/2/connectors/jobs?key=API_KEY&id=9274

Example

• Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector Job identifier.

try:
    # Retrieve a Connector Job
    api_response = api_instance.get_connector_jobs(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->get_connector_jobs: %s\n" % e) ```

• Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector Job identifier.

try:
    # Retrieve a Connector Job
    api_response = api_instance.get_connector_jobs(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->get_connector_jobs: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
id	int	A unique Connector Job identifier.

Return type

list[ConnectorJob]

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | A list of Connector Jobs. | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

get_connectors

list[Connector] get_connectors(id=id)

Retrieve a Connector

Retrieves one or more connectors available to your user. Connectors are not associated with a project or a memory. To retrieve a specific connector, specify the id request parameter. To retrieve all connectors, omit the id request parameter. Example CURL command: curl -X GET https://lilt.com/2/connectors?key=API_KEY&id=274

Example

• Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector identifier. (optional)

try:
    # Retrieve a Connector
    api_response = api_instance.get_connectors(id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->get_connectors: %s\n" % e) ```

• Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector identifier. (optional)

try:
    # Retrieve a Connector
    api_response = api_instance.get_connectors(id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->get_connectors: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
id	int	A unique Connector identifier.	[optional]

Return type

list[Connector]

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 200 | A list of Connectors. | - | 403 | User does not have permission for provided connector. | - | 410 | Connector deleted. | - | 0 | Unexpected error. | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

sync_connector

ConnectorJob sync_connector(id)

Sync a Connector

Request an import job for the given connector ID. This will check the target system for new content to pull into Lilt. Example CURL command: curl -X GET https://lilt.com/2/connectors/sync?key=API_KEY&id=128

Example

• Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector identifier.

try:
    # Sync a Connector
    api_response = api_instance.sync_connector(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->sync_connector: %s\n" % e) ```

• Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) id = 56 # int | A unique Connector identifier.

try:
    # Sync a Connector
    api_response = api_instance.sync_connector(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->sync_connector: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
id	int	A unique Connector identifier.

Return type

ConnectorJob

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

• Content-Type: Not defined
• Accept: application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 201 | A Connector Job object. | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]

update_connector

Connector update_connector(body)

Upload a Connector

Create a new connector linked to a supported external content source.

Example

• Api Key Authentication (ApiKeyAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) body = lilt.ConnectorArguments() # ConnectorArguments |

try:
    # Upload a Connector
    api_response = api_instance.update_connector(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->update_connector: %s\n" % e) ```

• Basic Authentication (BasicAuth): ```python from future import print_function import time import lilt from lilt.rest import ApiException from pprint import pprint

  Defining the host is optional and defaults to https://lilt.com/2

  See configuration.py for a list of all supported configuration parameters.

  configuration = lilt.Configuration( host = “https://lilt.com/2” )

The client must configure the authentication and authorization parameters

in accordance with the API server security policy.

Examples for each auth method are provided below, use the example that

satisfies your auth use case.

Configure API key authorization: ApiKeyAuth

configuration = lilt.Configuration( host = “https://lilt.com/2”, api_key = { ‘key’: ‘YOUR_API_KEY’ } )

Uncomment below to setup prefix (e.g. Bearer) for API key, if needed

configuration.api_key_prefix[‘key’] = ‘Bearer’

Configure HTTP basic authorization: BasicAuth

configuration = lilt.Configuration( username = ‘YOUR_USERNAME’, password = ‘YOUR_PASSWORD’ )

Enter a context with an instance of the API client

with lilt.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = lilt.ConnectorsApi(api_client) body = lilt.ConnectorArguments() # ConnectorArguments |

try:
    # Upload a Connector
    api_response = api_instance.update_connector(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectorsApi->update_connector: %s\n" % e) ```

Parameters

Name	Type	Description	Notes
body	ConnectorArguments

Return type

Connector

Authorization

ApiKeyAuth, BasicAuth

HTTP request headers

• Content-Type: application/json
• Accept: application/json

HTTP response details

| Status code | Description | Response headers | |————-|————-|——————| 201 | A Connector object. | - | 0 | Unexpected error | - |

[Back to top] [Back to API list] [Back to Model list] [Back to README]