Create a Linode using a public image

Here, we cover how to add a new Linode using one of the supported Linux distribution we offer. In the context of the Linode API, this is what we refer to as a "public image." Once the Linode is provisioned, you can then build your own software stack from scratch.

📘

The values shown in code snippets in this workflow are for example purposes only. Request body parameters and response output may be different for you when running these operations.

Get details

First, you need to gather a few values. Specifically, this includes information on the region where you want to create the Linode, the Linode plan, and the image type to use.

Choose a region

You need to determine the Akamai Cloud data center (region) where your Linode will live.

  1. Run the List regions operation.

    {
      "data": [
       {
         "capabilities": [
           "Linodes",
           "NodeBalancers",
           "Block Storage",
           "Object Storage",
           "Placement Groups",
           "Block Storage Encryption",
           "Linode Interfaces",
           "Premium Plans"
         ],
         "country": "us",
         "id": "us-lax", <== Store
         "label": "Washington, DC, USA",
         ...
    
  2. Consider where the majority of your requesting clients will be geographically, based on the label object. Choose an eligible region that's closest and store its id as your regionId.

    👍

    Review the capabilities object to ensure a region also offers all of the services you want included in your Linode. See Choose a Data Center for a complete list.

Choose a Linode plan

You need to decide on the type of Linode you want to use, based on your resource needs. Review Choose a Linode for complete details on all of the available types.

📘

Various Linode types are only available in certain regions:

  1. Run the List types operation.

  2. In the response, locate the label object for the applicable plan type and store its id as your linodeType.

    {
     "data": [
       {
         "id": "g6-dedicated-4", <== Store
         "label": "Dedicated 8GB",
         "price": {
           "hourly": 0.108,
           "monthly": 72.0
          },
          "region_prices": [
            {
              "id": "id-cgk",
              "hourly": 0.13,
              "monthly": 86.4
            },
            {
              "id": "br-gru",
              "hourly": 0.151,
              "monthly": 100.8
            }
          ],
          "addons": {
            "backups": {
              "price": {
                "hourly": 0.015,
                "monthly": 10.0
              },
              "region_prices": [
                {
                  "id": "id-cgk",
                  "hourly": 0.018,
                  "monthly": 12.0
                },
                {
                  "id": "br-gru",
                  "hourly": 0.021,
                  "monthly": 14.0
                }
              ]
            }
          },
          "memory": 8192,
          "disk": 163840,
          "transfer": 5000,
          "vcpus": 4,
          "gpus": 0,
          "network_out": 5000,
          "class": "dedicated",
          "successor": null,
          "capabilities": [],
          "accelerated_devices": 0
        },
        ...
      ],
      "page": 1,
      "pages": 1,
      "results": 47
    }
    

Choose an image type

We offer a host of public images you can apply on your Linode. Each offers a different Linux distribution you can apply as its operating system.

  1. Run the List images operation, without authentication. This filters the list of available images to the public image distributions we offer for use.

    📘

    For more details on the distributions we offer, see Choose a Linux distribution.

  2. From the response, find the distribution you want to use, based on its label and store its id as your imageId.

          {
             "id": "linode/debian13", <== Store.
             "label": "Debian 13",
             "deprecated": false,
             "size": 1800,
             "created": "2025-09-09T16:15:28",
             "updated": "2025-09-26T04:00:00",
             "description": "",
             "created_by": "linode",
             "type": "manual",
             "tags": [],
             "is_public": true,
             "vendor": "Debian",
             "expiry": null,
             "eol": "2030-06-30T04:00:00",
             "regions": null,
             "status": "available",
             "capabilities": [
                 "cloud-init"
             ]
         },
    

Create the Linode

Now, you're ready to create a new Linode using all of the values you've stored.

  1. Run the Create a Linode operation. Include the following values in the request:

    • label. Give your Linode an easily recognizable name.

    • region. Set this to your stored regionId.

    • image. Set this to your stored imageId.

    • type. Set this to your stored linodeType.

    • root_pass. Set a root user password that you'll use to access your Linode. The root user has access to the entire system, including files and commands. Make sure this is extremely strong to prevent attackers from gaining access to your system.

    • backups_enabled (Optional - incurs an additional cost). Set this to true to enroll your Linode in the Akamai Cloud Backup service. This creates periodic backups of your Linode.

    {
      "label": "TW-use_Debian_13_Linux_VM",
      "region": "us-lax",
      "type": "g6-dedicated-4",
      "image": "linode/debian13",
      "root_pass": "@-C0mpl3x-P@$$w0rd"
    }
    
  2. Set other body parameters in the request as desired.

    👍

    Add more security

    You can create an SSH key pair and add the public key to your Linode using the authorized_keys object with this operation. This automatically appends the key to the root user's ~/.ssh/authorized_keys file. This replaces the root_password and connections to the Linode will be resolved using the key pair. If you don't apply it now, you can run the Rebuild a Linode operation and target this Linode to add this security.

  3. From the response, store the id as your linodeId. Use this value to target your Linode with other API operations.

    {
      "id": 12345678, <== Store
      "label": "TW-use_Debian_13_Linux_VM",
      "group": "",
      "status": "provisioning",
      "created": "2025-10-28T20:40:20",
      "updated": "2025-10-28T20:40:20",
      "type": "g6-dedicated-4",
      "ipv4": [
        "123.456.789.10"
      ],
      "ipv6": "1a23:4b56::7890:1cde:f234/567",
      "image": "linode/debian13",
      "region": "us-lax",
      "site_type": "core",
      "specs": {
        "disk": 163840,
        "memory": 8192,
        "vcpus": 4,
        "gpus": 0,
        "transfer": 5000,
        "accelerated_devices": 0
      },
      "alerts": {
        "cpu": 360,
        "network_in": 10,
        "network_out": 10,
        "transfer_quota": 80,
        "io": 10000
      },
      "backups": {
        "enabled": false,
        "available": false,
        "schedule": {
          "day": null,
          "window": null
        },
        "last_successful": null
      },
      "hypervisor": "kvm",
      "watchdog_enabled": true,
      "tags": [],
      "host_uuid": "1a2345b6c7890123456defg7890h1i23j4kl5m6op",
      "has_user_data": false,
      "placement_group": null,
      "disk_encryption": "enabled",
      "lke_cluster_id": null,
      "capabilities": [
        "Block Storage Encryption",
        "SMTP Enabled"
      ]
    }
    

Check status

After you create your Linode, it takes some time to provision. Once it completes, it'll change to a status of running, indicating your Linode is ready to go.

  1. Run the Get a Linode operation, targeting your Linode using its stored linodeId.

  2. Review the status, looking for running.

    {
      "id": 12345678,
      "label": "TW-use_Debian_13_Linux_VM",
      "group": "",
      "status": "running", <== Check status
      "created": "2025-10-28T20:40:20",
      "updated": "2025-10-28T20:40:20",
      "type": "g6-dedicated-4",
      "ipv4": [
        "123.456.789.10"
      ],
      ...
    }