## NJALLA API Documentation

Copy pasted from https://njal.la/api/ because they require you to login to view the docs and that is dumb. 

As of 2023-05-05 the domains managed by Njalla are: 
- https://cyberia.pictures
- https://cyberia.top
- https://cyberia.social

API Endpoint: https://njal.la/api/1/ \
Requests follow the JSON-RPC 2.0 protocol.\
You can use session cookies or token based authentication.\
POST JSON body to the API Endpoint:

```
{
    "jsonrpc": "2.0",
    "method": "...",
    "params": {...},
    "id": "123"
}
```

 and you will get a JSON response. Success:

```
{
    "jsonrpc": "2.0",
    "result": {}.
    "id": "123"
}
```

 or error:

```
{
    "jsonrpc": "2.0",
    "error": {
        "code": 0
        "message": ""
    },
    "id": "123"
}
```

 Example using python requests

```
import requests

def njalla(method, **params):
    url = 'https://njal.la/api/1/'
    token = '<your-api-token>'
    headers = {
        'Authorization': 'Njalla ' + token
    }
    response = requests.post(url, json={
        'method': method,
        'params': params
    }, headers=headers).json()
    if 'result' not in response:
        raise Exception('API Error', response)
    return response['result']


print(njalla('list-domains'))
print(njalla('get-domain', domain='example.com'))
```

 Example using curl

```
NJALLA_TOKEN='<your-api-token>'
curl -s \
    -H "Accept: application/json" \
    -H "Content-Type: application/json" \
    -H "Authorization: Njalla ${NJALLA_TOKEN}" \
    --data '{"method":"get-domain", "params": {"domain": "exampe.com"}}' \
    https://njal.la/api/1/
```

# api

**add-token**

Add a new API token

```
params: {
    comment: string (optional)
    from: [string] (optional) array of IPv4 or IPv6 IPs or networks
                              that are allowed to use the token.
                              i.e.: ['8.8.8.8', '192.168.0.0/24']
}
returns: {
}
```

**check-task**

Check status of a long running task

```
params: {
    id: string
}
returns: {
    id: string
    status: object
}
```

**edit-token**

Edit API token

```
params: {
    key: string
    comment: string (optional)
    from: [string] (optional) array of IPv4 or IPv6 IPs or networks
                              that are allowed to use the token.
                              i.e.: ['8.8.8.8', '192.168.0.0/24']
}
returns: {
}
```

**list-tokens**

List existing API autorization tokens.

```
params: {
}
returns: {
    tokens: [...]
}
```

**remove-token**

Remove an existing API token

```
params: {
    key: string
}
returns: {
}
```

# domain

**add-dnssec**

Add DNSSEC record for domain

```
params: {
    domain: string
    algorithm: integer

    digest: string
    digest_type: integer
    key_tag: integer

    or

    public_key: string
}
returns: {
}
```

add-forward

Add email forward

```
params: {
    domain: string
    from: string
    to: string
}
returns: {
    domain: string
    from: string
    to: string
}
```

**add-glue**

Add glue record for the domain, name is the subdomain

```
params: {
    domain: string
    name: string
    address4: string
    address6: string
}
returns: {
}
```

**add-record**

Add new DNS Record to domain

```
params: {
    domain: string
    name: string
    content: string
    ttl: int
    type: string
    ...
}
returns: {
    id: int
    content: string
    domain: string
    name: string
    ttl: int
    type: string
}
```

**edit-domain**

Edit domain configuration

```
params: {
    domain: string
    ...
}
possible keys:
    mailforwarding: boolean
    dnssec: boolean
    lock: boolean
    contacts: custom whois contact ids
    nameservers: list of custom nameservers or empty list to use our nameservers

returns: {
    name: string,
    ...
}
```

**edit-glue**

Edit glue record

```
params: {
    domain: string
    name: string
    address4: string
    address6: string
}
returns: {
}
```

**edit-record**

Edit DNS Record

```
params: {
    domain: string
    id: int
    content: string
}
returns: {
}
```

**find-domains**

Find new domains

```
params: {
    query: string
}
returns: {
    domains: [
        {price: int, status: string, name: string}
    ]
}
```

**get-domain**

Get information about one of your domains

```
params: {
    domain: string
}
returns: {
    name: string,
    ...
}
```

**get-tlds**

Get list of supported TLDs

```
params: {
}
returns: {
    tld: {price: int, max_year: int, dnssec: boolean},
}
```

**import-zone**

Import BIND zone file

```
params: {
    domain: string
    zone: string
}
returns: {
}
```

**list-dnssec**

List DNSSEC records for domain

```
params: {
    domain: string
}
returns: {
    dnssec: list
}
```

**list-domains**

Get list of your domains

```
params: {
}
returns: {
    domains: list
}
```

**list-forwards**

List existing email forwards

```
params: {
    domain: string
}
returns: {
    forwards: list
}
```

**list-glue**

List glue records for domain

```
params: {
    domain: string
}
returns: {
    glue: list
}
```

**list-records**

List DNS records for given domain

```
params: {
    domain: string
}
returns: {
    records: list
}
```

**register-domain**

Register a new domain

```
params: {
    domain: string
    years: int (default: 1)
}
returns: {
    task: string
}
use check-task for response
```

**remove-dnssec**

Remove DNSSEC record from domain

```
params: {
    domain: string
    id: string
}
returns: {
}
```

**remove-forward**

Remove email forward

```
params: {
    domain: string
    from: string
    to: string
}
returns: {
}
```

**remove-glue**

Remove glue record

```
params: {
    domain: string
    name: string
}
returns: {
}
```

**remove-record**

Remove DNS Record

```
params: {
    domain: string
    id: int
}
returns: {
}
```

**renew-domain**

Renew one of your domains

```
params: {
    domain: string
    years: int (default: 1)
}
returns: {
    task: string
}
use check-task for response
```

# server

**add-server**

Create a new server with the given name, type, os and ssh\_key. Returns an id of the newly created server

```
params: {
    name: string,
    type: string
    os: string
    ssh_key: string
}
returns: {
    id: string
    ...
}
```

**edit-server**

Edit an existing server identified by id

```
params: {
    id: string
    name: string,
    type: string
    ssh_key: string
    reverse_name: string
}
returns: {
    ...
}
```

**get-server**

Returns information about one of your servers

```
params: {
    id: string
}
returns: {
    ...
}
```

**list-server-images**

Returns a list of server images that can be used for new servers

```
params: {
}
returns: {
    images: list
}
```

**list-server-types**

Returns a list of server types that can be used for new servers

```
params: {
}
returns: {
    types: list
}
```

**list-servers**

Retuns a list of your servers

```
params: {
}
returns: {
    servers: list
}
```

**remove-server**

Remote an existing server, your server will be stopped and all data deleted.

```
params: {
    id: string
}
returns: {
    ...
}
```

**renew-server**

Renew an existing server identified by id, your wallet must have enough credit to complete this operation.

```
params: {
    id: string
    months: int
}
returns: {
    ...
}
```

**reset-server**

Reset existing server and reinstall the given os. All data will be lost. Required field: `id`

```
params: {
    id: string
    os: string
    ssh_key: string
}
returns: {
    ...
}
```

**restart-server**

Restart existing server

```
params: {
    id: string
}
returns: {
    ...
}
```

**start-server**

Start existing server

```
params: {
    id: string
}
returns: {
    ...
}
```

**stop-server**

Stop existing server

```
params: {
    id: string
}
returns: {
    ...
}
```

# user

**login**

Login into an existing account (cookie based session). Consider using API tokens instead

```
params: {
    email: string [or] xmpp: string
    password: string
}
returns: {
}
```

**logout**

Logout and end your current session

```
params: {
}
returns: {
}
```

# vpn

**add-vpn**

Add a new VPN client Returns an id

```
params: {
    name: string,
    autorenew: boolean
}
returns: {
    id: string
    ...
}
```

**edit-vpn**

Edit an existing VPN identified by id

```
params: {
    id: string
    name: string,
    autorenew: boolean
    backend: wireguard|openvpn
    publickey: WireGuard PublicKey, set to your public key or null to genrate a new one
}
returns: {
    ...
}
```

**get-vpn**

Returns information about VPN

```
params: {
    id: string
}
returns: {
    ...
}
```

**list-vpns**

Retuns a list of your VPNs

```
params: {
}
returns: {
    vpns: list
}
```

**remove-vpn**

Remote an existing VPN

```
params: {
    id: string
}
returns: {
    ...
}
```

**renew-vpn**

Renew an existing VPN identified by id, your wallet must have enough credit to complete this operation.

```
params: {
    id: string
    months: int
}
returns: {
    ...
}
```

# wallet

add-payment

Refill your wallet

```
params: {
    amount: int (5 or multiple of 15, max: 300)
    via: string (options: paypal, bitcoin, litecoin, dash, monero, zcash, bitcoin-cash, ethereum, lightning-btc, transferwise-eur, transferwise-usd)
}
returns: {
    amount: int
    address: string (payment address)
    url: string (paypal url to process payment)
}
```

get-balance

```
params: {
}
returns: {
    balance: int (in euros)
}
```

get-payment

Get details about a payment

```
params: {
    id: string
}
returns: {
    id: string
    amount: int
    status: string
    address: string
    url: string
}
```

list-transactions

List transactions (payments, registrations, renewals, etc..) of the last 90 days

```
params: {
}
returns: {
    transactions: list
}
```