All URIs are relative to /api/v3
| Method | HTTP request | Description |
|---|---|---|
| crypto_certificatekeypairs_create | POST /crypto/certificatekeypairs/ | |
| crypto_certificatekeypairs_destroy | DELETE /crypto/certificatekeypairs/{kp_uuid}/ | |
| crypto_certificatekeypairs_generate_create | POST /crypto/certificatekeypairs/generate/ | |
| crypto_certificatekeypairs_list | GET /crypto/certificatekeypairs/ | |
| crypto_certificatekeypairs_partial_update | PATCH /crypto/certificatekeypairs/{kp_uuid}/ | |
| crypto_certificatekeypairs_retrieve | GET /crypto/certificatekeypairs/{kp_uuid}/ | |
| crypto_certificatekeypairs_update | PUT /crypto/certificatekeypairs/{kp_uuid}/ | |
| crypto_certificatekeypairs_used_by_list | GET /crypto/certificatekeypairs/{kp_uuid}/used_by/ | |
| crypto_certificatekeypairs_view_certificate_retrieve | GET /crypto/certificatekeypairs/{kp_uuid}/view_certificate/ | |
| crypto_certificatekeypairs_view_private_key_retrieve | GET /crypto/certificatekeypairs/{kp_uuid}/view_private_key/ |
CertificateKeyPair crypto_certificatekeypairs_create(certificate_key_pair_request)
CertificateKeyPair Viewset
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.certificate_key_pair import CertificateKeyPair
from authentik_client.models.certificate_key_pair_request import CertificateKeyPairRequest
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
certificate_key_pair_request = authentik_client.CertificateKeyPairRequest() # CertificateKeyPairRequest |
try:
api_response = api_instance.crypto_certificatekeypairs_create(certificate_key_pair_request)
print("The response of CryptoApi->crypto_certificatekeypairs_create:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_create: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| certificate_key_pair_request | CertificateKeyPairRequest |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 201 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
crypto_certificatekeypairs_destroy(kp_uuid)
CertificateKeyPair Viewset
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
kp_uuid = UUID('38400000-8cf0-11bd-b23e-10b96e4ef00d') # UUID | A UUID string identifying this Certificate-Key Pair.
try:
api_instance.crypto_certificatekeypairs_destroy(kp_uuid)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_destroy: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| kp_uuid | UUID | A UUID string identifying this Certificate-Key Pair. |
void (empty response body)
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 204 | No response body | - |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
CertificateKeyPair crypto_certificatekeypairs_generate_create(certificate_generation_request)
Generate a new, self-signed certificate-key pair
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.certificate_generation_request import CertificateGenerationRequest
from authentik_client.models.certificate_key_pair import CertificateKeyPair
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
certificate_generation_request = authentik_client.CertificateGenerationRequest() # CertificateGenerationRequest |
try:
api_response = api_instance.crypto_certificatekeypairs_generate_create(certificate_generation_request)
print("The response of CryptoApi->crypto_certificatekeypairs_generate_create:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_generate_create: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| certificate_generation_request | CertificateGenerationRequest |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | Bad request | - |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
PaginatedCertificateKeyPairList crypto_certificatekeypairs_list(has_key=has_key, key_type=key_type, managed=managed, name=name, ordering=ordering, page=page, page_size=page_size, search=search)
CertificateKeyPair Viewset
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.paginated_certificate_key_pair_list import PaginatedCertificateKeyPairList
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
has_key = True # bool | Only return certificate-key pairs with keys (optional)
key_type = ['key_type_example'] # List[str] | Filter by key algorithm type (RSA, EC, DSA, etc). Can be specified multiple times (e.g. '?key_type=rsa&key_type=ec') (optional)
managed = 'managed_example' # str | (optional)
name = 'name_example' # str | (optional)
ordering = 'ordering_example' # str | Which field to use when ordering the results. (optional)
page = 56 # int | A page number within the paginated result set. (optional)
page_size = 56 # int | Number of results to return per page. (optional)
search = 'search_example' # str | A search term. (optional)
try:
api_response = api_instance.crypto_certificatekeypairs_list(has_key=has_key, key_type=key_type, managed=managed, name=name, ordering=ordering, page=page, page_size=page_size, search=search)
print("The response of CryptoApi->crypto_certificatekeypairs_list:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_list: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| has_key | bool | Only return certificate-key pairs with keys | [optional] |
| key_type | List[str] | Filter by key algorithm type (RSA, EC, DSA, etc). Can be specified multiple times (e.g. '?key_type=rsa&key_type=ec') | [optional] |
| managed | str | [optional] | |
| name | str | [optional] | |
| ordering | str | Which field to use when ordering the results. | [optional] |
| page | int | A page number within the paginated result set. | [optional] |
| page_size | int | Number of results to return per page. | [optional] |
| search | str | A search term. | [optional] |
PaginatedCertificateKeyPairList
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
CertificateKeyPair crypto_certificatekeypairs_partial_update(kp_uuid, patched_certificate_key_pair_request=patched_certificate_key_pair_request)
CertificateKeyPair Viewset
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.certificate_key_pair import CertificateKeyPair
from authentik_client.models.patched_certificate_key_pair_request import PatchedCertificateKeyPairRequest
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
kp_uuid = UUID('38400000-8cf0-11bd-b23e-10b96e4ef00d') # UUID | A UUID string identifying this Certificate-Key Pair.
patched_certificate_key_pair_request = authentik_client.PatchedCertificateKeyPairRequest() # PatchedCertificateKeyPairRequest | (optional)
try:
api_response = api_instance.crypto_certificatekeypairs_partial_update(kp_uuid, patched_certificate_key_pair_request=patched_certificate_key_pair_request)
print("The response of CryptoApi->crypto_certificatekeypairs_partial_update:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_partial_update: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| kp_uuid | UUID | A UUID string identifying this Certificate-Key Pair. | |
| patched_certificate_key_pair_request | PatchedCertificateKeyPairRequest | [optional] |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
CertificateKeyPair crypto_certificatekeypairs_retrieve(kp_uuid)
CertificateKeyPair Viewset
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.certificate_key_pair import CertificateKeyPair
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
kp_uuid = UUID('38400000-8cf0-11bd-b23e-10b96e4ef00d') # UUID | A UUID string identifying this Certificate-Key Pair.
try:
api_response = api_instance.crypto_certificatekeypairs_retrieve(kp_uuid)
print("The response of CryptoApi->crypto_certificatekeypairs_retrieve:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_retrieve: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| kp_uuid | UUID | A UUID string identifying this Certificate-Key Pair. |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
CertificateKeyPair crypto_certificatekeypairs_update(kp_uuid, certificate_key_pair_request)
CertificateKeyPair Viewset
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.certificate_key_pair import CertificateKeyPair
from authentik_client.models.certificate_key_pair_request import CertificateKeyPairRequest
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
kp_uuid = UUID('38400000-8cf0-11bd-b23e-10b96e4ef00d') # UUID | A UUID string identifying this Certificate-Key Pair.
certificate_key_pair_request = authentik_client.CertificateKeyPairRequest() # CertificateKeyPairRequest |
try:
api_response = api_instance.crypto_certificatekeypairs_update(kp_uuid, certificate_key_pair_request)
print("The response of CryptoApi->crypto_certificatekeypairs_update:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_update: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| kp_uuid | UUID | A UUID string identifying this Certificate-Key Pair. | |
| certificate_key_pair_request | CertificateKeyPairRequest |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
List[UsedBy] crypto_certificatekeypairs_used_by_list(kp_uuid)
Get a list of all objects that use this object
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.used_by import UsedBy
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
kp_uuid = UUID('38400000-8cf0-11bd-b23e-10b96e4ef00d') # UUID | A UUID string identifying this Certificate-Key Pair.
try:
api_response = api_instance.crypto_certificatekeypairs_used_by_list(kp_uuid)
print("The response of CryptoApi->crypto_certificatekeypairs_used_by_list:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_used_by_list: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| kp_uuid | UUID | A UUID string identifying this Certificate-Key Pair. |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
CertificateData crypto_certificatekeypairs_view_certificate_retrieve(kp_uuid, download=download)
Return certificate-key pairs certificate and log access
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.certificate_data import CertificateData
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
kp_uuid = UUID('38400000-8cf0-11bd-b23e-10b96e4ef00d') # UUID | A UUID string identifying this Certificate-Key Pair.
download = True # bool | (optional)
try:
api_response = api_instance.crypto_certificatekeypairs_view_certificate_retrieve(kp_uuid, download=download)
print("The response of CryptoApi->crypto_certificatekeypairs_view_certificate_retrieve:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_view_certificate_retrieve: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| kp_uuid | UUID | A UUID string identifying this Certificate-Key Pair. | |
| download | bool | [optional] |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
CertificateData crypto_certificatekeypairs_view_private_key_retrieve(kp_uuid, download=download)
Return certificate-key pairs private key and log access
- Bearer Authentication (authentik):
import authentik_client
from authentik_client.models.certificate_data import CertificateData
from authentik_client.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to /api/v3
# See configuration.py for a list of all supported configuration parameters.
configuration = authentik_client.Configuration(
host = "/api/v3"
)
# 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 Bearer authorization: authentik
configuration = authentik_client.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with authentik_client.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = authentik_client.CryptoApi(api_client)
kp_uuid = UUID('38400000-8cf0-11bd-b23e-10b96e4ef00d') # UUID | A UUID string identifying this Certificate-Key Pair.
download = True # bool | (optional)
try:
api_response = api_instance.crypto_certificatekeypairs_view_private_key_retrieve(kp_uuid, download=download)
print("The response of CryptoApi->crypto_certificatekeypairs_view_private_key_retrieve:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling CryptoApi->crypto_certificatekeypairs_view_private_key_retrieve: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| kp_uuid | UUID | A UUID string identifying this Certificate-Key Pair. | |
| download | bool | [optional] |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | - | |
| 400 | - | |
| 403 | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]