{
    "openapi": "3.0.0",
    "info": {
        "title": "Simply.com API v3 (beta)",
        "description": "Version 3 of the Simply.com API is in beta. Endpoints, fields and behaviour may still change without notice, so pin integrations that need stability to version 2. Documentation for this API can be found on https://www.simply.com/docs/api/",
        "termsOfService": "https://www.simply.com/terms-of-service/",
        "version": "3.0.0-beta"
    },
    "servers": [
        {
            "url": "https://api.simply.com"
        }
    ],
    "paths": {
        "/3/accounts/": {
            "get": {
                "tags": [
                    "accounts"
                ],
                "summary": "Retrieve list of accounts",
                "description": "Retrieve the accounts the credential has access to. An API key has access to its own account only. An OAuth token has access to every account the user is a member of. Use the account name in account-scoped endpoints such as /accounts/{account}/invoices/.",
                "operationId": "getAccountList",
                "responses": {
                    "200": {
                        "description": "List of accounts retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "accounts": {
                                            "description": "Array of accounts",
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "account": {
                                                        "description": "Account name",
                                                        "type": "string",
                                                        "example": "S123456"
                                                    },
                                                    "name": {
                                                        "description": "Company name, or the account holder name when no company is set",
                                                        "type": "string",
                                                        "example": "Example Company"
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    }
                }
            }
        },
        "/3/accounts/{account}/invoices/": {
            "get": {
                "tags": [
                    "billing"
                ],
                "summary": "Retrieve list of invoices",
                "description": "Retrieve list of all paid, credited, and refunded invoices for the account. Invoices are returned in reverse chronological order (newest first).",
                "operationId": "getAccountInvoices",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "List of invoices retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "invoices": {
                                            "description": "Array of invoices",
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "date": {
                                                        "description": "Payment date",
                                                        "type": "string",
                                                        "format": "date-time",
                                                        "example": "2026-01-15T10:30:00Z"
                                                    },
                                                    "invoiceno": {
                                                        "description": "Invoice number",
                                                        "type": "string",
                                                        "example": "2026-12345"
                                                    },
                                                    "reference": {
                                                        "description": "Product reference/handle",
                                                        "type": "string",
                                                        "example": "example.com",
                                                        "nullable": true
                                                    },
                                                    "subject": {
                                                        "description": "Invoice subject/description",
                                                        "type": "string",
                                                        "example": "Domain renewal for example.com"
                                                    },
                                                    "amount": {
                                                        "description": "Invoice amount",
                                                        "type": "number",
                                                        "format": "float",
                                                        "example": 99.95
                                                    },
                                                    "currency": {
                                                        "description": "Currency code (ISO 4217)",
                                                        "type": "string",
                                                        "example": "DKK"
                                                    },
                                                    "transactionno": {
                                                        "description": "Payment transaction number",
                                                        "type": "string",
                                                        "example": "TXN123456"
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/AccountNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/databases/mysql/": {
            "get": {
                "tags": [
                    "database"
                ],
                "summary": "List MySQL databases for a product",
                "description": "Returns all MySQL databases attached to the product. Passwords are not returned.",
                "operationId": "getMysqlDatabases",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Successful response with MySQL databases",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "databases": {
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "hostname": {
                                                        "type": "string",
                                                        "example": "mysql1.unoeuro.com"
                                                    },
                                                    "port": {
                                                        "type": "integer",
                                                        "example": 3306
                                                    },
                                                    "username": {
                                                        "type": "string",
                                                        "example": "example_dk"
                                                    },
                                                    "database": {
                                                        "type": "string",
                                                        "example": "example_dk_main"
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/dns/records/": {
            "get": {
                "tags": [
                    "dnszone"
                ],
                "summary": "Retrieve all DNS records for a product",
                "description": "Returns a complete list of all DNS records in the zone, including A, AAAA, CNAME, MX, TXT, SRV, and other record types.",
                "operationId": "getDnsRecords",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Successful response with DNS records",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "records": {
                                            "description": "Array of DNS records in the zone",
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "record_id": {
                                                        "description": "Unique identifier for the DNS record",
                                                        "type": "integer",
                                                        "example": 123
                                                    },
                                                    "name": {
                                                        "description": "The hostname or label for the DNS record",
                                                        "type": "string",
                                                        "example": "example.com"
                                                    },
                                                    "ttl": {
                                                        "description": "Time To Live in seconds",
                                                        "type": "integer",
                                                        "example": 3600
                                                    },
                                                    "data": {
                                                        "description": "The record data (IP address, hostname, text value, etc.)",
                                                        "type": "string",
                                                        "example": "192.168.1.1"
                                                    },
                                                    "type": {
                                                        "description": "DNS record type",
                                                        "type": "string",
                                                        "example": "A"
                                                    },
                                                    "priority": {
                                                        "description": "Priority value (used for MX and SRV records)",
                                                        "type": "integer",
                                                        "example": 10,
                                                        "nullable": true
                                                    },
                                                    "comment": {
                                                        "description": "Optional comment for the DNS record",
                                                        "type": "string",
                                                        "example": "Primary record",
                                                        "nullable": true
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product not found",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "error": {
                                            "type": "string",
                                            "example": "Unknown or invalid product reference"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    }
                }
            },
            "post": {
                "tags": [
                    "dnszone"
                ],
                "summary": "Add new DNS record to a product DNS zone",
                "description": "Creates a new DNS record in the DNS zone. Supports all common record types including A, AAAA, CNAME, MX, TXT, SRV, and more.",
                "operationId": "addDnsRecord",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/DnsRecordPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "200": {
                        "description": "DNS record created successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "record": {
                                            "properties": {
                                                "id": {
                                                    "description": "ID of the newly created record",
                                                    "type": "integer",
                                                    "example": 123
                                                }
                                            },
                                            "type": "object"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "400": {
                        "description": "Invalid request data or validation error",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "error": {
                                            "type": "string",
                                            "example": "Invalid DNS record type"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/dns/records/{record_id}/": {
            "put": {
                "tags": [
                    "dnszone"
                ],
                "summary": "Update a DNS record in a product DNS zone",
                "description": "Updates an existing DNS record. All fields should be provided, as this is a full update operation. The DNS zone will be automatically reloaded if changes are detected.",
                "operationId": "updateDnsRecord",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    },
                    {
                        "$ref": "#/components/parameters/record_id"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/DnsRecordPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "400": {
                        "description": "Invalid request data or validation error",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "error": {
                                            "type": "string",
                                            "example": "Invalid DNS record type"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product or DNS record not found"
                    }
                }
            },
            "delete": {
                "tags": [
                    "dnszone"
                ],
                "summary": "Remove DNS record from a product DNS zone",
                "description": "Deletes a specific DNS record by its ID. The DNS zone will be automatically reloaded after deletion.",
                "operationId": "deleteDnsRecord",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    },
                    {
                        "$ref": "#/components/parameters/record_id"
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product or DNS record not found"
                    }
                }
            }
        },
        "/3/products/{product}/dns/reload/": {
            "post": {
                "tags": [
                    "dnszone"
                ],
                "summary": "Force-reload a DNS zone",
                "description": "Manually triggers a DNS zone reload. Usually not necessary as zone reloads happen automatically after record modifications.",
                "operationId": "reloadDnsZone",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/dns/": {
            "get": {
                "tags": [
                    "dnszone"
                ],
                "summary": "Retrieve DNS zone metadata",
                "description": "Retrieve meta information about a DNS zone for a product, including zone name and configuration.",
                "operationId": "getDnsZone",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "DNS zone information retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "zone": {
                                            "properties": {
                                                "name": {
                                                    "description": "The domain name of the DNS zone",
                                                    "type": "string",
                                                    "example": "example.com"
                                                }
                                            },
                                            "type": "object"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/accounts/{account}/domain-contacts/": {
            "get": {
                "tags": [
                    "domaincontacts"
                ],
                "summary": "List domain contacts",
                "description": "Returns the domain contacts on the account. A domain contact holds its own owner information and can be assigned to a domain, so domains on the same account can have different owners. Domains without a domain contact use the account information. Requires administrator access to the account.",
                "operationId": "getDomainContacts",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "List of domain contacts",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "contacts": {
                                            "type": "array",
                                            "items": {
                                                "$ref": "#/components/schemas/DomainContactData"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/AccountNotFound"
                    }
                }
            },
            "post": {
                "tags": [
                    "domaincontacts"
                ],
                "summary": "Create a domain contact",
                "description": "Creates a domain contact on the account. The contact is validated the same way as in the controlpanel, including VAT numbers and personal identification numbers. The Punktum dk handle is created automatically by the registry the first time the contact is used on a .dk domain.",
                "operationId": "addDomainContact",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/DomainContactPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "200": {
                        "description": "Domain contact created",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "contact": {
                                            "properties": {
                                                "id": {
                                                    "description": "ID of the newly created domain contact",
                                                    "type": "integer",
                                                    "example": 12
                                                }
                                            },
                                            "type": "object"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "400": {
                        "$ref": "#/components/responses/DomainContactInvalid"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/AccountNotFound"
                    }
                }
            }
        },
        "/3/accounts/{account}/domain-contacts/{contact_id}/": {
            "get": {
                "tags": [
                    "domaincontacts"
                ],
                "summary": "Retrieve a domain contact",
                "operationId": "getDomainContact",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    },
                    {
                        "$ref": "#/components/parameters/contact_id"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "The domain contact",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "contact": {
                                            "$ref": "#/components/schemas/DomainContactData"
                                        },
                                        "domains": {
                                            "description": "Domains that use this contact as owner",
                                            "type": "array",
                                            "items": {
                                                "type": "string",
                                                "example": "example.com"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Account or domain contact not found"
                    }
                }
            },
            "put": {
                "tags": [
                    "domaincontacts"
                ],
                "summary": "Update a domain contact",
                "description": "Replaces the owner information of the domain contact. Fields that are left out are cleared. The updated information is sent to the registry for every domain that uses the contact, in the background.",
                "operationId": "updateDomainContact",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    },
                    {
                        "$ref": "#/components/parameters/contact_id"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/DomainContactPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "204": {
                        "description": "Domain contact updated"
                    },
                    "400": {
                        "$ref": "#/components/responses/DomainContactInvalid"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Account or domain contact not found"
                    }
                }
            },
            "delete": {
                "tags": [
                    "domaincontacts"
                ],
                "summary": "Delete a domain contact",
                "description": "Deletes the domain contact. A contact that is still used by a domain cannot be deleted; assign the domains to another contact or to the account information first.",
                "operationId": "deleteDomainContact",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    },
                    {
                        "$ref": "#/components/parameters/contact_id"
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Domain contact deleted"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Account or domain contact not found"
                    },
                    "409": {
                        "description": "The domain contact is still used by one or more domains",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ErrorResponse"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/3/products/{product}/domain-contact/": {
            "put": {
                "tags": [
                    "domaincontacts"
                ],
                "summary": "Set the domain contact of a domain",
                "description": "Assigns a domain contact to the product domain, or switches the domain back to the account information with a null contact_id. The owner change is sent to the registry immediately; if the registry rejects it, the previous owner is kept.",
                "operationId": "setProductDomainContact",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/SetDomainContactPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "204": {
                        "description": "Domain contact changed and sent to the registry"
                    },
                    "400": {
                        "description": "The registry rejected the owner change",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ErrorResponse"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product or domain contact not found"
                    },
                    "409": {
                        "description": "The owner of this domain cannot be changed through the API",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ErrorResponse"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/3/domains/{domain}/availability/": {
            "get": {
                "tags": [
                    "domains"
                ],
                "summary": "Check domain availability",
                "description": "Check if a domain is available for registration or can be transferred. Supports both ASCII and internationalized domain names (IDN). By default only the registration check is performed; pass type=transfer to run the transfer check instead. Only the fields belonging to the checks that ran are returned. This endpoint is rate limited: on a 429, wait for the period given in the Retry-After header before retrying.",
                "operationId": "getDomainAvailability",
                "parameters": [
                    {
                        "name": "domain",
                        "in": "path",
                        "description": "The fully qualified domain name to check (e.g., example.com)",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "example": "example.com"
                    },
                    {
                        "name": "type",
                        "in": "query",
                        "description": "Which checks to run. \"register\" (the default) reports whether the domain can be registered and returns \"available\" and \"canregister\". \"transfer\" reports whether it can be transferred and returns \"cantransfer\"; use it only for a domain already known to be registered.",
                        "required": false,
                        "schema": {
                            "type": "string",
                            "default": "register",
                            "enum": [
                                "register",
                                "transfer"
                            ]
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Domain check completed successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "domain": {
                                            "description": "Domain availability information",
                                            "properties": {
                                                "name": {
                                                    "description": "The checked domain name (IDN format)",
                                                    "type": "string",
                                                    "example": "example.com"
                                                },
                                                "extension": {
                                                    "description": "The domain extension/TLD",
                                                    "type": "string",
                                                    "example": "com"
                                                },
                                                "status": {
                                                    "description": "Domain status",
                                                    "type": "string",
                                                    "example": "available",
                                                    "enum": [
                                                        "available",
                                                        "taken",
                                                        "error"
                                                    ]
                                                },
                                                "available": {
                                                    "description": "Whether the domain is available for registration. Omitted when type=transfer.",
                                                    "type": "boolean",
                                                    "example": true
                                                },
                                                "canregister": {
                                                    "description": "Whether the domain can be registered. Omitted when type=transfer.",
                                                    "type": "boolean",
                                                    "example": true
                                                },
                                                "cantransfer": {
                                                    "description": "Whether the domain can be transferred. Omitted when type=register, which is the default.",
                                                    "type": "boolean",
                                                    "example": false
                                                }
                                            },
                                            "type": "object"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "429": {
                        "description": "Rate limit exceeded. Wait for the period given in the Retry-After header before retrying."
                    }
                }
            }
        },
        "/3/products/{product}/logs/firewall/": {
            "get": {
                "tags": [
                    "logs"
                ],
                "summary": "Stream web application firewall logs for a product",
                "description": "Streams web application firewall blocks for every hostname on the product (primary domain, subdomains and domain aliases) within a time window, as newline-delimited JSON (application/x-ndjson). Each line is one JSON object. The window is required and may not exceed 24 hours. Entries are ordered oldest-first.",
                "operationId": "getFirewallLogs",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    },
                    {
                        "name": "from",
                        "in": "query",
                        "description": "Start of the time window, ISO 8601 UTC. The window may not exceed 24 hours.",
                        "required": true,
                        "schema": {
                            "type": "string",
                            "format": "date-time"
                        },
                        "example": "2026-08-21T00:00:00Z"
                    },
                    {
                        "name": "to",
                        "in": "query",
                        "description": "End of the time window, ISO 8601 UTC. The window may not exceed 24 hours.",
                        "required": true,
                        "schema": {
                            "type": "string",
                            "format": "date-time"
                        },
                        "example": "2026-08-22T00:00:00Z"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "A stream of newline-delimited JSON objects, one firewall entry per line.",
                        "content": {
                            "application/x-ndjson": {
                                "schema": {
                                    "properties": {
                                        "timestamp": {
                                            "type": "string",
                                            "format": "date-time",
                                            "example": "2026-08-21T12:34:56Z"
                                        },
                                        "hostname": {
                                            "type": "string",
                                            "example": "example.com",
                                            "nullable": true
                                        },
                                        "uri": {
                                            "type": "string",
                                            "example": "/wp-login.php",
                                            "nullable": true
                                        },
                                        "client_ip": {
                                            "type": "string",
                                            "example": "1.2.3.4",
                                            "nullable": true
                                        },
                                        "user_agent": {
                                            "type": "string",
                                            "example": "curl/8.0.1",
                                            "nullable": true
                                        },
                                        "rule_messages": {
                                            "type": "array",
                                            "items": {
                                                "type": "string"
                                            },
                                            "example": [
                                                "SQL Injection Attack Detected"
                                            ]
                                        },
                                        "country": {
                                            "description": "ISO 3166-1 alpha-2 country code.",
                                            "type": "string",
                                            "example": "DK",
                                            "nullable": true
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/mail/accounts/": {
            "get": {
                "tags": [
                    "mail"
                ],
                "summary": "List mail accounts for a product",
                "description": "Returns all email accounts on the product. Passwords are not returned.",
                "operationId": "getMailAccounts",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Successful response with mail accounts",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "accounts": {
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "username": {
                                                        "type": "string",
                                                        "example": "john@example.com"
                                                    },
                                                    "email": {
                                                        "type": "string",
                                                        "example": "john@example.com"
                                                    },
                                                    "suspended": {
                                                        "type": "boolean",
                                                        "example": false
                                                    },
                                                    "autoreply": {
                                                        "type": "boolean",
                                                        "example": false
                                                    },
                                                    "quota_disk_used_bytes": {
                                                        "type": "integer",
                                                        "example": 52428800,
                                                        "nullable": true
                                                    },
                                                    "quota_disk_limit_bytes": {
                                                        "type": "integer",
                                                        "example": 1000000000,
                                                        "nullable": true
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            },
            "post": {
                "tags": [
                    "mail"
                ],
                "summary": "Add new mail account to a product",
                "description": "Creates a new email account for the product. The email address will be username@domain. The account will be created with the product's default mail quota.",
                "operationId": "addMailAccount",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/AddMailAccountPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/mail/forwards/": {
            "get": {
                "tags": [
                    "mail"
                ],
                "summary": "List mail forwards for a product",
                "description": "Returns all mail forwards on the product, forwarding an address on the product to another destination.",
                "operationId": "getMailForwards",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Successful response with mail forwards",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "forwards": {
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "id": {
                                                        "type": "integer",
                                                        "example": 12345
                                                    },
                                                    "address": {
                                                        "type": "string",
                                                        "example": "sales@example.com"
                                                    },
                                                    "destination": {
                                                        "type": "string",
                                                        "example": "team@other.com"
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            },
            "post": {
                "tags": [
                    "mail"
                ],
                "summary": "Add new mail forward to a product",
                "description": "Creates a forward-only email address (localpart@domain) that forwards incoming mail to an external destination address.",
                "operationId": "addMailForward",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/AddMailForwardPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/mail/forwards/{forward_id}/": {
            "delete": {
                "tags": [
                    "mail"
                ],
                "summary": "Remove a mail forward from a product",
                "description": "Deletes a mail forward by its ID, as returned when listing mail forwards. Mail to the address is no longer forwarded to that destination.",
                "operationId": "deleteMailForward",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    },
                    {
                        "name": "forward_id",
                        "in": "path",
                        "description": "The id of a mail forward on the product.",
                        "required": true,
                        "schema": {
                            "type": "integer",
                            "pattern": "\\d+"
                        }
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product or mail forward not found"
                    }
                }
            }
        },
        "/3/orderable-products/": {
            "get": {
                "tags": [
                    "order"
                ],
                "summary": "List the products that can be ordered",
                "description": "Returns every product that can be passed as \"product\" to the order endpoint.",
                "operationId": "getOrderableProducts",
                "responses": {
                    "200": {
                        "description": "List of orderable products retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "products": {
                                            "description": "Array of orderable products",
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "product": {
                                                        "description": "Value to send as \"product\" when placing an order",
                                                        "type": "string",
                                                        "example": "basicsuite"
                                                    },
                                                    "name": {
                                                        "description": "Human readable product name",
                                                        "type": "string",
                                                        "example": "Basic Suite"
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    }
                }
            }
        },
        "/3/accounts/{account}/orders/": {
            "post": {
                "tags": [
                    "order"
                ],
                "summary": "Order a product with optional domain registration/transfer",
                "description": "Order a product, optionally registering or transferring a domain. Call /orderable-products/ for the list of values accepted in \"product\". If payment is required, a working credit card must be on file. The order will be processed immediately if payment succeeds.",
                "operationId": "createOrder",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/OrderPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "200": {
                        "description": "Order created and processed successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "order": {
                                            "description": "Order information (only present if payment was required)",
                                            "properties": {
                                                "payment_id": {
                                                    "description": "Payment ID for the order",
                                                    "type": "integer",
                                                    "example": 12345
                                                }
                                            },
                                            "type": "object",
                                            "nullable": true
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "400": {
                        "description": "Invalid request data, unsupported product, domain status mismatch, or payment failed",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "error": {
                                            "type": "string",
                                            "example": "Provided domain has unsupported or non-matching status"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/AccountNotFound"
                    }
                }
            }
        },
        "/3/products/": {
            "get": {
                "tags": [
                    "products"
                ],
                "summary": "Retrieve list of products",
                "description": "Retrieve all active products on every account the credential has access to, including hosting packages, domains, and DNS services. Products are ordered by handle.",
                "operationId": "getProductList",
                "responses": {
                    "200": {
                        "description": "List of products retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "products": {
                                            "type": "array",
                                            "items": {
                                                "$ref": "#/components/schemas/Product"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    }
                }
            }
        },
        "/3/accounts/{account}/products/": {
            "get": {
                "tags": [
                    "products"
                ],
                "summary": "Retrieve list of products on an account",
                "description": "Retrieve all active products on the account, including hosting packages, domains, and DNS services. Products are ordered by handle.",
                "operationId": "getAccountProductList",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/account"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "List of products retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "products": {
                                            "type": "array",
                                            "items": {
                                                "$ref": "#/components/schemas/Product"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/AccountNotFound"
                    }
                }
            }
        },
        "/3/products/{product}/registry/nameservers/": {
            "get": {
                "tags": [
                    "registry"
                ],
                "summary": "Retrieve the current nameservers of a domain",
                "description": "Returns the nameservers currently registered for the product's domain at its registry.",
                "operationId": "getNameservers",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Nameservers retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "nameservers": {
                                            "description": "Nameservers reported by the registry",
                                            "type": "array",
                                            "items": {
                                                "type": "string",
                                                "example": "ns1.simply.com"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product not found or domain not managed by a known registry"
                    }
                }
            },
            "put": {
                "tags": [
                    "registry"
                ],
                "summary": "Set the nameservers of a domain at the registry",
                "description": "Replaces the nameserver set registered for the product's domain at its registry. The registry call may take a few seconds to propagate.",
                "operationId": "setNameservers",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/SetNameserversPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product not found or domain not managed by a known registry"
                    },
                    "409": {
                        "description": "Domain is locked for updates at the registry",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ErrorResponse"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/3/products/{product}/registry/dnssec/": {
            "get": {
                "tags": [
                    "registry"
                ],
                "summary": "Retrieve DNSSEC keys registered on a domain",
                "description": "Returns the DNSSEC keys (DS or DNSKEY records) currently published at the registry for the product's domain. Each key includes the record type and its standard zone-file representation.",
                "operationId": "getDnssecKeys",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "DNSSEC keys retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "dnssec_keys": {
                                            "description": "DNSSEC keys published at the registry",
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "type": {
                                                        "description": "Record type",
                                                        "type": "string",
                                                        "example": "ds",
                                                        "enum": [
                                                            "ds",
                                                            "dnskey"
                                                        ]
                                                    },
                                                    "data": {
                                                        "description": "Zone-file formatted record data",
                                                        "type": "string",
                                                        "example": "12345 13 2 abc123..."
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product not found or domain not managed by a known registry"
                    }
                }
            },
            "post": {
                "tags": [
                    "registry"
                ],
                "summary": "Add a DNSSEC key to a domain",
                "description": "Publishes a new DS or DNSKEY record at the registry for the product's domain. Keys that already exist on the domain are a no-op.",
                "operationId": "addDnssecKey",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/AddDnsSecKeyPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "400": {
                        "$ref": "#/components/responses/BadRequest"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product not found or domain not managed by a known registry"
                    }
                }
            },
            "delete": {
                "tags": [
                    "registry"
                ],
                "summary": "Remove all DNSSEC keys from a domain",
                "description": "Disables DNSSEC by removing every DS and DNSKEY record at the registry for the product's domain.",
                "operationId": "removeDnssec",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product not found or domain not managed by a known registry"
                    }
                }
            }
        },
        "/3/server-status/messages/": {
            "get": {
                "tags": [
                    "serverstatus"
                ],
                "summary": "Retrieve server status messages",
                "description": "Retrieve a list of current and past server status messages, including planned maintenance and incidents. Returns messages from the last 6 months.",
                "operationId": "getServerStatusMessages",
                "responses": {
                    "200": {
                        "description": "Successful response with past and present messages",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "messages": {
                                            "description": "Array of server status messages",
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "text": {
                                                        "description": "Message content in markdown format",
                                                        "type": "string",
                                                        "example": "Scheduled maintenance will occur on server cluster X"
                                                    },
                                                    "date_start": {
                                                        "description": "Start date/time of the event",
                                                        "type": "string",
                                                        "format": "date-time",
                                                        "example": "2026-01-21T10:00:00Z"
                                                    },
                                                    "date_end": {
                                                        "description": "End date/time of the event (null if ongoing)",
                                                        "type": "string",
                                                        "format": "date-time",
                                                        "example": "2026-01-21T12:00:00Z",
                                                        "nullable": true
                                                    },
                                                    "type": {
                                                        "description": "Type of message (planned for scheduled maintenance, or omitted for incidents)",
                                                        "type": "string",
                                                        "example": "planned",
                                                        "nullable": true
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    }
                }
            }
        },
        "/3/products/{product}/subdomains/": {
            "get": {
                "tags": [
                    "subdomains"
                ],
                "summary": "List subdomains for a product",
                "description": "Returns all subdomains configured on the product web hosting, along with the document root folder each one serves. Creating a subdomain does not create a DNS record, so a subdomain listed here is not necessarily resolving. Products without web hosting return an empty list.",
                "operationId": "getSubdomains",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Successful response with subdomains",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "subdomains": {
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "name": {
                                                        "description": "The subdomain label, without the domain",
                                                        "type": "string",
                                                        "example": "shop"
                                                    },
                                                    "fqdn": {
                                                        "description": "The full hostname of the subdomain",
                                                        "type": "string",
                                                        "example": "shop.example.com"
                                                    },
                                                    "folder": {
                                                        "description": "The document root the subdomain serves, relative to the FTP root",
                                                        "type": "string",
                                                        "example": "/public_html/shop"
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            }
        },
        "/3/tickets/": {
            "get": {
                "tags": [
                    "support"
                ],
                "summary": "Retrieve list of support tickets",
                "description": "Retrieve the support tickets created by the authenticated user, newest first.",
                "operationId": "getSupportTickets",
                "responses": {
                    "200": {
                        "description": "List of support tickets retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "tickets": {
                                            "description": "Array of support tickets",
                                            "type": "array",
                                            "items": {
                                                "$ref": "#/components/schemas/SupportTicketData"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    }
                }
            }
        },
        "/3/tickets/{ticket}/": {
            "get": {
                "tags": [
                    "support"
                ],
                "summary": "Retrieve a support ticket",
                "description": "Retrieve a support ticket created by the authenticated user, including its comments in chronological order and its attachments.",
                "operationId": "getSupportTicket",
                "parameters": [
                    {
                        "name": "ticket",
                        "in": "path",
                        "description": "The ticket id, as found in the /tickets/ endpoint.",
                        "required": true,
                        "schema": {
                            "type": "integer",
                            "pattern": "\\d+"
                        },
                        "example": 123456
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Support ticket retrieved successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "ticket": {
                                            "$ref": "#/components/schemas/SupportTicketData"
                                        },
                                        "comments": {
                                            "description": "Comments on the ticket, oldest first",
                                            "type": "array",
                                            "items": {
                                                "$ref": "#/components/schemas/SupportTicketCommentData"
                                            }
                                        },
                                        "attachments": {
                                            "description": "Files attached to the ticket",
                                            "type": "array",
                                            "items": {
                                                "$ref": "#/components/schemas/SupportTicketAttachmentData"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Ticket not found"
                    }
                }
            }
        },
        "/3/products/{product}/url-forwards/": {
            "get": {
                "tags": [
                    "urlforwards"
                ],
                "summary": "List URL forwards for a product",
                "description": "Returns every URL forward configured on the product domain. A URL forward answers HTTP requests for a hostname with a redirect to another URL, and is backed by an A record pointing at the Simply.com forwarding server.",
                "operationId": "getUrlForwards",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "Successful response with URL forwards",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "forwards": {
                                            "type": "array",
                                            "items": {
                                                "properties": {
                                                    "id": {
                                                        "description": "Unique identifier for the URL forward",
                                                        "type": "integer",
                                                        "example": 123
                                                    },
                                                    "host": {
                                                        "description": "The hostname visitors request",
                                                        "type": "string",
                                                        "example": "www.example.com"
                                                    },
                                                    "target": {
                                                        "description": "The URL visitors are forwarded to",
                                                        "type": "string",
                                                        "example": "https://example.com/shop/"
                                                    },
                                                    "status_code": {
                                                        "description": "The HTTP status code used for the redirect",
                                                        "type": "integer",
                                                        "example": 301
                                                    },
                                                    "with_path": {
                                                        "description": "Whether the requested path is appended to the target URL",
                                                        "type": "boolean",
                                                        "example": false
                                                    }
                                                },
                                                "type": "object"
                                            }
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    }
                }
            },
            "post": {
                "tags": [
                    "urlforwards"
                ],
                "summary": "Add a URL forward to a product",
                "description": "Creates a URL forward on the product domain. Any existing A, AAAA or CNAME record for the hostname is replaced by an A record pointing at the Simply.com forwarding server, so the forward takes effect once DNS has propagated. The target URL must be publicly reachable.",
                "operationId": "addUrlForward",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    }
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/UrlForwardPayload"
                            }
                        }
                    }
                },
                "responses": {
                    "200": {
                        "description": "URL forward created successfully",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "forward": {
                                            "properties": {
                                                "id": {
                                                    "description": "ID of the newly created URL forward",
                                                    "type": "integer",
                                                    "example": 123
                                                },
                                                "host": {
                                                    "description": "The hostname visitors request",
                                                    "type": "string",
                                                    "example": "www.example.com"
                                                }
                                            },
                                            "type": "object"
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "400": {
                        "description": "Invalid request data or validation error",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "properties": {
                                        "error": {
                                            "type": "string",
                                            "example": "Invalid external URL"
                                        },
                                        "code": {
                                            "description": "Machine-readable rejection code, present when the forwarding server rejected the forward",
                                            "type": "string",
                                            "example": "REDIRECT_LOOP_SELF",
                                            "nullable": true
                                        }
                                    },
                                    "type": "object"
                                }
                            }
                        }
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "$ref": "#/components/responses/ProductNotFound"
                    },
                    "409": {
                        "description": "A URL forward already exists for the hostname",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/ErrorResponse"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/3/products/{product}/url-forwards/{forward_id}/": {
            "delete": {
                "tags": [
                    "urlforwards"
                ],
                "summary": "Remove a URL forward from a product",
                "description": "Deletes a URL forward by its ID and removes the A record pointing at the Simply.com forwarding server. The hostname stops resolving unless another record is added for it.",
                "operationId": "deleteUrlForward",
                "parameters": [
                    {
                        "$ref": "#/components/parameters/product"
                    },
                    {
                        "$ref": "#/components/parameters/forward_id"
                    }
                ],
                "responses": {
                    "204": {
                        "description": "Operation completed successfully"
                    },
                    "401": {
                        "$ref": "#/components/responses/Unauthorized"
                    },
                    "403": {
                        "$ref": "#/components/responses/AccessDenied"
                    },
                    "404": {
                        "description": "Product or URL forward not found"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "ErrorResponse": {
                "properties": {
                    "error": {
                        "type": "string",
                        "example": "Invalid request data"
                    }
                },
                "type": "object"
            },
            "Product": {
                "properties": {
                    "handle": {
                        "description": "Product identifier to use in product endpoints",
                        "type": "string",
                        "example": "example.com"
                    },
                    "uri": {
                        "description": "The base URL of the product in API calls",
                        "type": "string",
                        "example": "/3/products/example.com/"
                    },
                    "account": {
                        "description": "Name of the account that owns the product",
                        "type": "string",
                        "example": "S123456"
                    },
                    "name": {
                        "description": "Product name/handle",
                        "type": "string",
                        "example": "example.com"
                    },
                    "cancelled": {
                        "description": "Whether the product has been cancelled",
                        "type": "boolean",
                        "example": false
                    },
                    "domain": {
                        "description": "Domain information for the product",
                        "properties": {
                            "name": {
                                "description": "Domain name in Unicode form (IDN domains are not punycode-encoded)",
                                "type": "string",
                                "example": "bl\u00e5b\u00e6r.dk"
                            },
                            "name_idn": {
                                "description": "Domain name in ASCII form (IDN domains are punycode-encoded)",
                                "type": "string",
                                "example": "xn--blbr-roah.dk"
                            },
                            "managed": {
                                "description": "Whether the domain is registered and managed by Simply.com",
                                "type": "boolean",
                                "example": true
                            },
                            "date_renewdate": {
                                "description": "Next renewal date for the domain (null if not managed)",
                                "type": "string",
                                "format": "date-time",
                                "example": "2027-01-21T00:00:00Z",
                                "nullable": true
                            },
                            "contact_id": {
                                "description": "ID of the domain contact that owns the domain, or null when the domain uses the account information. See /accounts/{account}/domain-contacts/.",
                                "type": "integer",
                                "example": 12,
                                "nullable": true
                            }
                        },
                        "type": "object"
                    },
                    "product": {
                        "description": "Product service information",
                        "properties": {
                            "id": {
                                "description": "Service ID",
                                "type": "integer",
                                "example": 42
                            },
                            "name": {
                                "description": "Service name",
                                "type": "string",
                                "example": "DNS Service"
                            },
                            "date_created": {
                                "description": "Product creation date",
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-21T10:00:00Z"
                            },
                            "date_expire": {
                                "description": "Product expiration date (null for products without expiration)",
                                "type": "string",
                                "format": "date-time",
                                "example": "2027-01-21T10:00:00Z",
                                "nullable": true
                            }
                        },
                        "type": "object"
                    },
                    "usernames": {
                        "description": "Service access usernames (only present for hosting products)",
                        "properties": {
                            "ftp": {
                                "description": "FTP username",
                                "type": "string",
                                "example": "user123"
                            },
                            "ssh": {
                                "description": "SSH username",
                                "type": "string",
                                "example": "user123"
                            },
                            "mysql": {
                                "description": "MySQL username",
                                "type": "string",
                                "example": "user123_db"
                            },
                            "mssql": {
                                "description": "MSSQL username",
                                "type": "string",
                                "example": "user123_db"
                            }
                        },
                        "type": "object",
                        "nullable": true
                    },
                    "servers": {
                        "description": "Server information. Web/FTP/SSH entries are only present for hosting products.",
                        "properties": {
                            "nameservers": {
                                "description": "Simply.com nameservers currently assigned to the domain in our system. Does not query the registry.",
                                "type": "array",
                                "items": {
                                    "type": "string",
                                    "example": "ns1.simply.com"
                                }
                            },
                            "webserver": {
                                "description": "Web server information",
                                "properties": {
                                    "hostname": {
                                        "description": "Server hostname",
                                        "type": "string",
                                        "example": "server42.simply.com"
                                    },
                                    "ip": {
                                        "description": "Server IP address",
                                        "type": "string",
                                        "example": "1.2.3.4"
                                    }
                                },
                                "type": "object",
                                "nullable": true
                            },
                            "ftpserver": {
                                "description": "FTP server information",
                                "properties": {
                                    "username": {
                                        "description": "FTP username",
                                        "type": "string",
                                        "example": "user123"
                                    },
                                    "hostname": {
                                        "description": "FTP hostname",
                                        "type": "string",
                                        "example": "ftp.simply.com"
                                    }
                                },
                                "type": "object",
                                "nullable": true
                            },
                            "sshserver": {
                                "description": "SSH server information. Add public-key manually through Simply.com Controlpanel.",
                                "properties": {
                                    "auth": {
                                        "description": "Authentication method",
                                        "type": "string",
                                        "example": "publickey"
                                    },
                                    "username": {
                                        "description": "SSH username",
                                        "type": "string",
                                        "example": "user123"
                                    },
                                    "hostname": {
                                        "description": "SSH hostname",
                                        "type": "string",
                                        "example": "ssh.simply.com"
                                    }
                                },
                                "type": "object",
                                "nullable": true
                            }
                        },
                        "type": "object"
                    }
                },
                "type": "object"
            },
            "DnsRecordType": {
                "type": "string",
                "enum": [
                    "A",
                    "CNAME",
                    "AAAA",
                    "ALIAS",
                    "MX",
                    "TXT",
                    "NS",
                    "DS",
                    "DNSKEY",
                    "SRV",
                    "SPF",
                    "SOA",
                    "HTTPS",
                    "LOC",
                    "CAA",
                    "SSHFP",
                    "TLSA"
                ]
            },
            "DnsRecordPayload": {
                "required": [
                    "type",
                    "name",
                    "data"
                ],
                "properties": {
                    "type": {
                        "$ref": "#/components/schemas/DnsRecordType"
                    },
                    "name": {
                        "description": "The hostname or label for the DNS record",
                        "type": "string",
                        "example": "www.example.com"
                    },
                    "data": {
                        "description": "The record data (IP address, hostname, text value, etc.)",
                        "type": "string",
                        "pattern": "((?![^[:print:]]).)*",
                        "example": "1.2.3.4"
                    },
                    "ttl": {
                        "description": "Time To Live in seconds. Defaults to zone default if not specified.",
                        "type": "integer",
                        "example": 3600,
                        "nullable": true,
                        "default": null
                    },
                    "priority": {
                        "description": "Priority value (required for MX and SRV records)",
                        "type": "integer",
                        "example": 10,
                        "nullable": true,
                        "default": null
                    },
                    "comment": {
                        "description": "Optional comment for the DNS record",
                        "type": "string",
                        "example": "Production server",
                        "nullable": true,
                        "default": null
                    }
                },
                "type": "object"
            },
            "DomainContactPayload": {
                "required": [
                    "name",
                    "address",
                    "zipcode",
                    "city",
                    "country",
                    "phone_prefix",
                    "phone",
                    "email"
                ],
                "properties": {
                    "name": {
                        "description": "Full name of the contact person",
                        "type": "string",
                        "example": "Jane Doe"
                    },
                    "address": {
                        "description": "Street address",
                        "type": "string",
                        "example": "Example Street 1"
                    },
                    "zipcode": {
                        "description": "Postal code",
                        "type": "string",
                        "example": "1000"
                    },
                    "city": {
                        "description": "City",
                        "type": "string",
                        "example": "Copenhagen"
                    },
                    "country": {
                        "description": "Country as an ISO 3166-1 alpha-2 code",
                        "type": "string",
                        "example": "DK"
                    },
                    "phone_prefix": {
                        "description": "Phone country calling code, without the plus sign",
                        "type": "integer",
                        "example": 45
                    },
                    "phone": {
                        "description": "Phone number without the country calling code",
                        "type": "string",
                        "example": "12345678"
                    },
                    "email": {
                        "description": "Email address of the contact",
                        "type": "string",
                        "example": "jane@example.com"
                    },
                    "description": {
                        "description": "Description shown only in the controlpanel and the API, never sent to the registry",
                        "type": "string",
                        "example": "Client domains",
                        "nullable": true,
                        "default": null
                    },
                    "company": {
                        "description": "Company name. Leave empty for a private individual.",
                        "type": "string",
                        "example": "Example Company",
                        "nullable": true,
                        "default": null
                    },
                    "vat_number": {
                        "description": "European VAT number, without the country prefix. Requires a company.",
                        "type": "string",
                        "example": "12345678",
                        "nullable": true,
                        "default": null
                    },
                    "org_number": {
                        "description": "Organisation number for a company without a European VAT number. Requires a company.",
                        "type": "string",
                        "example": null,
                        "nullable": true,
                        "default": null
                    },
                    "personal_number": {
                        "description": "Personal identification number, required by some registries for private individuals",
                        "type": "string",
                        "example": null,
                        "nullable": true,
                        "default": null
                    },
                    "personal_number_country": {
                        "description": "Country that issued the personal identification number, as an ISO 3166-1 alpha-2 code. Defaults to the contact country.",
                        "type": "string",
                        "example": "DK",
                        "nullable": true,
                        "default": null
                    },
                    "birthday": {
                        "description": "Date of birth as YYYY-MM-DD, required by some registries for private individuals",
                        "type": "string",
                        "format": "date",
                        "example": null,
                        "nullable": true,
                        "default": null
                    },
                    "passport": {
                        "description": "Passport number",
                        "type": "string",
                        "example": null,
                        "nullable": true,
                        "default": null
                    },
                    "whois_email": {
                        "description": "Email address published on domains. Defaults to the contact email.",
                        "type": "string",
                        "example": "domains@example.com",
                        "nullable": true,
                        "default": null
                    },
                    "norid_person_id": {
                        "description": "Norid person ID, required to register .no domains for private individuals",
                        "type": "string",
                        "example": "N.PRI.12345678",
                        "nullable": true,
                        "default": null
                    }
                },
                "type": "object"
            },
            "SetDomainContactPayload": {
                "properties": {
                    "contact_id": {
                        "description": "ID of the domain contact to use as owner of the domain, or null to use the account information",
                        "type": "integer",
                        "example": 12,
                        "nullable": true,
                        "default": null
                    }
                },
                "type": "object"
            },
            "AddMailAccountPayload": {
                "required": [
                    "localpart",
                    "password"
                ],
                "properties": {
                    "localpart": {
                        "description": "The local part of the email address (before @). Must be unique for the domain.",
                        "type": "string",
                        "example": "john"
                    },
                    "password": {
                        "description": "Password for the email account. Should be a strong password.",
                        "type": "string",
                        "example": "VERYSECRET"
                    }
                },
                "type": "object"
            },
            "AddMailForwardPayload": {
                "required": [
                    "localpart",
                    "destination"
                ],
                "properties": {
                    "localpart": {
                        "description": "The local part of the forward address (before @). The forward address will be localpart@domain.",
                        "type": "string",
                        "example": "sales"
                    },
                    "destination": {
                        "description": "The destination email address that incoming mail will be forwarded to.",
                        "type": "string",
                        "example": "team@other.com"
                    }
                },
                "type": "object"
            },
            "OrderPayload": {
                "required": [
                    "product",
                    "domain",
                    "domainaction"
                ],
                "properties": {
                    "product": {
                        "description": "Shortname of the product to order, as listed by the /orderable-products/ endpoint.",
                        "type": "string",
                        "example": "basicsuite"
                    },
                    "domain": {
                        "description": "Fully qualified domain name. Both ASCII and IDN domains are supported.",
                        "type": "string",
                        "example": "example.com"
                    },
                    "domainaction": {
                        "description": "Action to perform on the domain. Must match domain availability status.",
                        "type": "string",
                        "example": "register",
                        "enum": [
                            "register",
                            "transfer",
                            "transferonly",
                            "none"
                        ],
                        "x-enumDescriptions": {
                            "register": "Register a new domain name (domain must be available)",
                            "transfer": "Transfer a domain and update nameservers to Simply.com (domain must be taken)",
                            "transferonly": "Transfer a domain without nameserver changes (domain must be taken)",
                            "none": "Use existing domain without registration or transfer (domain must be taken)"
                        }
                    },
                    "authid": {
                        "description": "Authorization code for domain transfer (optional)",
                        "type": "string",
                        "example": "AUTH12345CODE",
                        "nullable": true,
                        "default": null
                    },
                    "coupon": {
                        "description": "Optional coupon code to apply to the order",
                        "type": "string",
                        "example": "FOOBAR",
                        "nullable": true,
                        "default": null
                    },
                    "autorenew": {
                        "description": "Whether to enable automatic renewal for the product. Enabled unless explicitly set to false.",
                        "type": "boolean",
                        "example": true,
                        "default": true
                    }
                },
                "type": "object"
            },
            "SetNameserversPayload": {
                "required": [
                    "nameservers"
                ],
                "properties": {
                    "nameservers": {
                        "description": "List of 2 to 13 hostnames to set as the domain's nameservers at the registry. Order is preserved where the registry supports it.",
                        "type": "array",
                        "items": {
                            "type": "string",
                            "example": "ns1.simply.com"
                        },
                        "maxItems": 13,
                        "minItems": 2
                    }
                },
                "type": "object"
            },
            "AddDnsSecKeyPayload": {
                "required": [
                    "type",
                    "data"
                ],
                "properties": {
                    "type": {
                        "description": "DNSSEC record type",
                        "type": "string",
                        "example": "ds",
                        "enum": [
                            "ds",
                            "dnskey"
                        ]
                    },
                    "data": {
                        "description": "Zone-file formatted record data. For DS: \"keytag algorithm digestType digest\". For DNSKEY: \"flags protocol algorithm pubkey\".",
                        "type": "string",
                        "example": "12345 13 2 49fd46e6c4b45c55d4ac69c9c59cb3f3d2c3e91c10db85b2e3f1c12c4a0e3f1c"
                    }
                },
                "type": "object"
            },
            "UrlForwardPayload": {
                "required": [
                    "target"
                ],
                "properties": {
                    "target": {
                        "description": "The URL visitors are forwarded to",
                        "type": "string",
                        "example": "https://example.com/shop/"
                    },
                    "name": {
                        "description": "The hostname to forward from, as a label on the product domain. Omit it, or use an empty string or @, to forward the domain itself.",
                        "type": "string",
                        "example": "www",
                        "default": ""
                    },
                    "status_code": {
                        "description": "The HTTP status code used for the redirect",
                        "type": "integer",
                        "example": 301,
                        "default": 301,
                        "enum": [
                            301,
                            302
                        ]
                    },
                    "with_path": {
                        "description": "Append the requested path to the target URL",
                        "type": "boolean",
                        "example": false,
                        "default": false
                    }
                },
                "type": "object"
            },
            "DomainContactData": {
                "required": [
                    "id",
                    "name",
                    "address",
                    "zipcode",
                    "city",
                    "phone_prefix",
                    "phone",
                    "email"
                ],
                "properties": {
                    "id": {
                        "description": "Domain contact ID",
                        "type": "integer",
                        "example": 12
                    },
                    "description": {
                        "description": "Description shown only in the controlpanel and the API",
                        "type": "string",
                        "example": "Client domains",
                        "nullable": true
                    },
                    "company": {
                        "description": "Company name",
                        "type": "string",
                        "example": "Example Company",
                        "nullable": true
                    },
                    "vat_number": {
                        "description": "European VAT number",
                        "type": "string",
                        "example": "12345678",
                        "nullable": true
                    },
                    "org_number": {
                        "description": "Organisation number",
                        "type": "string",
                        "example": null,
                        "nullable": true
                    },
                    "name": {
                        "description": "Full name of the contact person",
                        "type": "string",
                        "example": "Jane Doe"
                    },
                    "personal_number": {
                        "description": "Personal identification number",
                        "type": "string",
                        "example": null,
                        "nullable": true
                    },
                    "personal_number_country": {
                        "description": "Country that issued the personal identification number (ISO 3166-1 alpha-2)",
                        "type": "string",
                        "example": "DK",
                        "nullable": true
                    },
                    "birthday": {
                        "description": "Date of birth",
                        "type": "string",
                        "format": "date",
                        "example": null,
                        "nullable": true
                    },
                    "passport": {
                        "description": "Passport number",
                        "type": "string",
                        "example": null,
                        "nullable": true
                    },
                    "address": {
                        "description": "Street address",
                        "type": "string",
                        "example": "Example Street 1"
                    },
                    "zipcode": {
                        "description": "Postal code",
                        "type": "string",
                        "example": "1000"
                    },
                    "city": {
                        "description": "City",
                        "type": "string",
                        "example": "Copenhagen"
                    },
                    "country": {
                        "description": "Country (ISO 3166-1 alpha-2)",
                        "type": "string",
                        "example": "DK",
                        "nullable": true
                    },
                    "phone_prefix": {
                        "description": "Phone country calling code",
                        "type": "integer",
                        "example": 45
                    },
                    "phone": {
                        "description": "Phone number without the country calling code",
                        "type": "string",
                        "example": "12345678"
                    },
                    "email": {
                        "description": "Email address of the contact",
                        "type": "string",
                        "example": "jane@example.com"
                    },
                    "whois_email": {
                        "description": "Email address published on domains",
                        "type": "string",
                        "example": "domains@example.com",
                        "nullable": true
                    },
                    "norid_person_id": {
                        "description": "Norid person ID",
                        "type": "string",
                        "example": "N.PRI.12345678",
                        "nullable": true
                    },
                    "dk_handle": {
                        "description": "Punktum dk handle used for .dk domains. Created automatically by the registry and cannot be changed.",
                        "type": "string",
                        "example": "AB1234-DK",
                        "nullable": true
                    }
                },
                "type": "object"
            },
            "SupportTicketData": {
                "required": [
                    "id",
                    "subject",
                    "status",
                    "date_created",
                    "url"
                ],
                "properties": {
                    "id": {
                        "description": "Ticket id",
                        "type": "integer",
                        "example": 123456
                    },
                    "subject": {
                        "description": "Ticket subject",
                        "type": "string",
                        "example": "DNS records not updating"
                    },
                    "status": {
                        "description": "Ticket status",
                        "type": "string",
                        "example": "open",
                        "enum": [
                            "open",
                            "closed"
                        ]
                    },
                    "domain": {
                        "description": "Domain the ticket concerns",
                        "type": "string",
                        "example": "example.com",
                        "nullable": true
                    },
                    "date_created": {
                        "description": "Date the ticket was created",
                        "type": "string",
                        "format": "date-time",
                        "example": "2026-01-15T10:30:00+00:00"
                    },
                    "date_closed": {
                        "description": "Date the ticket was closed (null while open)",
                        "type": "string",
                        "format": "date-time",
                        "example": null,
                        "nullable": true
                    },
                    "url": {
                        "description": "Link to the ticket on www.simply.com. Anyone with the link can read and reply to the ticket.",
                        "type": "string",
                        "format": "uri",
                        "example": "https://www.simply.com/dk/support/tickets/123456/abcdef0123456789/"
                    }
                },
                "type": "object"
            },
            "SupportTicketCommentData": {
                "required": [
                    "id",
                    "date",
                    "from",
                    "comment"
                ],
                "properties": {
                    "id": {
                        "description": "Comment id",
                        "type": "integer",
                        "example": 987654
                    },
                    "date": {
                        "description": "Comment date",
                        "type": "string",
                        "format": "date-time",
                        "example": "2026-01-15T10:30:00+00:00"
                    },
                    "from": {
                        "description": "Whether the comment was written by Simply.com staff or by the customer",
                        "type": "string",
                        "example": "staff",
                        "enum": [
                            "staff",
                            "customer"
                        ]
                    },
                    "name": {
                        "description": "Name of the staff member. Null for customer comments.",
                        "type": "string",
                        "example": "Peter",
                        "nullable": true
                    },
                    "comment": {
                        "description": "Comment text in Markdown",
                        "type": "string",
                        "example": "The DNS records have been updated."
                    }
                },
                "type": "object"
            },
            "SupportTicketAttachmentData": {
                "required": [
                    "id",
                    "date",
                    "filename",
                    "mime"
                ],
                "properties": {
                    "id": {
                        "description": "Attachment id",
                        "type": "integer",
                        "example": 4567
                    },
                    "date": {
                        "description": "Upload date",
                        "type": "string",
                        "format": "date-time",
                        "example": "2026-01-15T10:30:00+00:00"
                    },
                    "filename": {
                        "description": "Original filename",
                        "type": "string",
                        "example": "screenshot.png"
                    },
                    "mime": {
                        "description": "MIME type",
                        "type": "string",
                        "example": "image/png"
                    }
                },
                "type": "object"
            }
        },
        "responses": {
            "BadRequest": {
                "description": "Invalid request data or validation error",
                "content": {
                    "application/json": {
                        "schema": {
                            "$ref": "#/components/schemas/ErrorResponse"
                        }
                    }
                }
            },
            "Unauthorized": {
                "description": "Authentication failed"
            },
            "AccessDenied": {
                "description": "Access denied"
            },
            "ProductNotFound": {
                "description": "Product not found"
            },
            "AccountNotFound": {
                "description": "Account not found"
            },
            "DomainContactInvalid": {
                "description": "The domain contact failed validation",
                "content": {
                    "application/json": {
                        "schema": {
                            "properties": {
                                "error": {
                                    "type": "string",
                                    "example": "Invalid domain contact"
                                },
                                "fields": {
                                    "description": "Validation message per field",
                                    "type": "object",
                                    "additionalProperties": {
                                        "type": "string"
                                    }
                                }
                            },
                            "type": "object"
                        }
                    }
                }
            }
        },
        "parameters": {
            "product": {
                "name": "product",
                "in": "path",
                "description": "The product handle, as found in the /products/ endpoint.",
                "required": true,
                "schema": {
                    "type": "string"
                },
                "example": "example.com"
            },
            "account": {
                "name": "account",
                "in": "path",
                "description": "The account name, as found in the /accounts/ endpoint.",
                "required": true,
                "schema": {
                    "type": "string"
                },
                "example": "S123456"
            },
            "record_id": {
                "name": "record_id",
                "in": "path",
                "description": "The id of a DNS record in a DNS zone.",
                "required": true,
                "schema": {
                    "type": "integer"
                }
            },
            "forward_id": {
                "name": "forward_id",
                "in": "path",
                "description": "The id of a URL forward on a product domain.",
                "required": true,
                "schema": {
                    "type": "integer"
                }
            },
            "contact_id": {
                "name": "contact_id",
                "in": "path",
                "description": "The id of a domain contact on the account.",
                "required": true,
                "schema": {
                    "type": "integer"
                }
            }
        },
        "securitySchemes": {
            "bearerAuth": {
                "type": "http",
                "description": "Send an account API-key as a Bearer token in the Authorization header.",
                "scheme": "bearer"
            },
            "oauth2": {
                "type": "oauth2",
                "description": "OAuth 2.1 authorization code flow with PKCE (S256), acting on behalf of a Simply.com user. Register a client through dynamic client registration at https://www.simply.com/oauth/register/. A user token covers every account the user is a member of, subject to their role on each account.",
                "flows": {
                    "authorizationCode": {
                        "authorizationUrl": "https://www.simply.com/controlpanel/user/oauth/authorize/",
                        "tokenUrl": "https://www.simply.com/oauth/token/",
                        "refreshUrl": "https://www.simply.com/oauth/token/",
                        "scopes": {
                            "read": "Read-only access to the user and the accounts and products the user has access to. Allows GET requests only.",
                            "write": "Full access to the user and the accounts and products the user has access to"
                        }
                    }
                }
            }
        }
    },
    "security": [
        {
            "bearerAuth": []
        },
        {
            "oauth2": [
                "write"
            ]
        }
    ],
    "tags": [
        {
            "name": "accounts",
            "description": "List the accounts the credential has access to."
        },
        {
            "name": "billing",
            "description": "Retrieve account invoices and billing history."
        },
        {
            "name": "order",
            "description": "Create new product and domain orders."
        },
        {
            "name": "products",
            "description": "List and inspect hosting and service products."
        },
        {
            "name": "dnszone",
            "description": "Manage DNS zones and records on the Simply.com nameservers."
        },
        {
            "name": "urlforwards",
            "description": "Manage URL forwards, redirecting a hostname on a product domain to another URL."
        },
        {
            "name": "domaincontacts",
            "description": "Manage domain contacts, giving domains on the same account different owners than the account information."
        },
        {
            "name": "mail",
            "description": "Create and manage email accounts for a product."
        },
        {
            "name": "database",
            "description": "List the databases attached to a product."
        },
        {
            "name": "subdomains",
            "description": "List the subdomains configured on a product web hosting."
        },
        {
            "name": "logs",
            "description": "Stream webserver and web application firewall logs for a product within a time window."
        },
        {
            "name": "registry",
            "description": "Read and manage registry-level data for a domain, such as its nameservers and DNSSEC keys."
        },
        {
            "name": "domains",
            "description": "Check domain availability for registration or transfer."
        },
        {
            "name": "serverstatus",
            "description": "Public server-status messages including planned maintenance and incident notifications."
        },
        {
            "name": "support",
            "description": "Read the support tickets created by the authenticated user."
        }
    ]
}