> ## Documentation Index
> Fetch the complete documentation index at: https://checkly-422f444a-paula-tree-202-entitlements-group-troubles.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# PrivateLocation Construct

> Learn how to configure private locations with the Checkly CLI.

<Tip>
  Learn more about Private Locations in [the Private Locations overview](platform/private-locations/overview).
</Tip>

Use Private Location to create private locations for running checks from your own infrastructure, VPCs, or segregated networks. This enables monitoring of internal services and applications not accessible from the public internet.

<Accordion title="Prerequisites">
  Before creating private locations, ensure you have:

  * An initialized Checkly CLI project
  * Access to the infrastructure where you'll deploy the private location agent
  * Network connectivity from your infrastructure to Checkly's API endpoints
  * Understanding of your internal network topology and security requirements
  * Administrative privileges to deploy and run the private location agent

  For additional setup information, see [CLI overview](/cli/overview).
</Accordion>

<CodeGroup>
  ```ts Basic Example theme={null}
  import { PrivateLocation } from "checkly/constructs"

  const myPrivateLocation = new PrivateLocation("private-location-1", {
    name: "My Private Location",
    icon: "server",
    slugName: "my-private-location"
  })
  ```

  ```ts Check using a private location theme={null}
  import { ApiCheck, PrivateLocation } from "checkly/constructs"

  const datacenterLocation = new PrivateLocation("datacenter-east-1", {
    name: "East Coast Datacenter",
    icon: "building",
    slugName: "datacenter-east-1",
    proxyUrl: "http://proxy.datacenter.local:8080",
  })

  // Use the private location in a check
  new ApiCheck("internal-api-check", {
    name: "Internal API Check",
    privateLocations: [datacenterLocation],
    request: {
      method: "GET",
      url: "https://internal-api.company.local/health",
    },
  })
  ```
</CodeGroup>

## Configuration

| Parameter  | Type     | Required | Default | Description                                                                          |
| ---------- | -------- | -------- | ------- | ------------------------------------------------------------------------------------ |
| `name`     | `string` | ✅        | -       | Friendly name for your private location                                              |
| `slugName` | `string` | ✅        | -       | Unique slug identifier (must be unique across your account)                          |
| `icon`     | `string` | ❌        | -       | [Octicon name](https://primer.style/octicons/) to distinguish the location in the UI |
| `proxyUrl` | `string` | ❌        | -       | Proxy URL for outgoing HTTP calls from this location                                 |

## Private Location Options

<ResponseField name="name" type="string" required>
  Friendly name for your private location that will be displayed in the Checkly dashboard and used for identification.

  **Usage:**

  ```ts theme={null}
  new PrivateLocation("my-location", {
    name: "Corporate Data Center",
    slugName: "corporate-data-center"
  })
  ```
</ResponseField>

<ResponseField name="slugName" type="string" required>
  Unique slug identifier for your private location. This must be unique across your entire Checkly account and is used for referencing the location.

  **Usage:**

  ```ts theme={null}
  new PrivateLocation("my-location", {
    name: "My Location",
    slugName: "my-unique-location-slug",
  })
  ```

  **Examples:**

  <Tabs>
    <Tab title="Good Naming Practices">
      ```ts theme={null}
      // Descriptive and stable slugs
      new PrivateLocation("corp-vpc-east", {
        name: "Corporate VPC East",
        slugName: "corporate-vpc-east-1",
      })

      new PrivateLocation("k8s-prod", {
        name: "Production Kubernetes",
        slugName: "k8s-production-cluster"
      })

      new PrivateLocation("datacenter-west", {
        name: "West Coast Datacenter",
        slugName: "datacenter-west-coast"
      })
      ```
    </Tab>

    <Tab title="Avoid These Patterns">
      ```ts theme={null}
      // Too generic or likely to change
      new PrivateLocation("location-1", {
        name: "Location 1",
        slugName: "location-1" // Too generic
      })

      new PrivateLocation("temp-loc", {
        name: "Temporary Location",
        slugName: "temp-location-2024" // Date-based, will become outdated
      })
      ```
    </Tab>
  </Tabs>

  <Warning>
    The `slugName` must be unique across your entire Checkly account and cannot be changed after creation. Choose descriptive, stable names.
  </Warning>
</ResponseField>

<ResponseField name="icon" type="string">
  Octicon name to visually distinguish the location in the Checkly UI. Choose icons that represent your infrastructure type or purpose.

  Usage:

  ```ts theme={null}
  new PrivateLocation("my-location", {
    name: "Database Zone",
    icon: "database",
    slugName: "database-zone"
  })
  ```

  **Available icons**: Any [Octicon](https://primer.style/design/foundations/icons) name (e.g., `server`, `database`, `cloud`, `shield`, `container`, `tools`, `building`)
</ResponseField>

<ResponseField name="proxyUrl" type="string">
  Proxy URL for outgoing HTTP calls from this private location. Use when your infrastructure requires all external traffic to go through a corporate proxy.

  Usage:

  ```ts theme={null}
  new PrivateLocation('corporate-location', {
    name: 'Corporate Network',
    slugName: 'corporate-network',
    proxyUrl: 'http://proxy.company.local:8080'
  })
  ```

  ## Referencing Existing Locations

  Reference private locations by using their construct reference or by slug names if they were created outside your CLI project:

  <Tabs>
    <Tab title="By Construct Reference">
      ```ts theme={null}
      const privateLocationVpcEast = new PrivateLocation("corp-vpc-east", {
        name: "Corporate VPC East",
        slugName: "corporate-vpc-east-1",
      })

      new ApiCheck("existing-location-reference", {
        name: "Check Using Existing Reference",
        privateLocations: [privateLocationVpcEast], // Construct reference
        request: {
          method: "GET",
          url: "https://internal.company.local/health"
        }
      })
      ```
    </Tab>

    <Tab title="By Slug Name">
      ```ts theme={null}
      new ApiCheck("existing-location-check", {
        name: "Check Using Existing Location",
        privateLocations: ["existing-datacenter-slug"], // String reference
        request: {
          method: "GET",
          url: "https://internal.company.local/health"
        }
      })
      ```
    </Tab>

    <Tab title="Mixed References">
      ```ts theme={null}
      // Combine new and existing private locations
      const newLocation = new PrivateLocation("new-location", {
        name: "New Private Location",
        slugName: "new-location"
      })

      new ApiCheck("mixed-locations-check", {
        name: "Check with Mixed Locations",
        privateLocations: [
          newLocation,              // Construct reference
          "existing-location-slug"  // Existing location by slug
        ],
        request: {
          method: "GET",
          url: "https://internal.company.local/health"
        }
      })
      ```
    </Tab>
  </Tabs>

  <Tip>All checks and monitors that support the `privateLocations` option can run in your private location</Tip>

  **Examples:**

  <Tabs>
    <Tab title="HTTP Proxy">
      ```ts theme={null}
      new PrivateLocation("corp-proxy-location", {
        name: "Corporate Network with Proxy",
        slugName: "corporate-with-proxy",
        proxyUrl: "http://proxy.company.local:8080"
      })
      ```
    </Tab>

    <Tab title="HTTPS Proxy">
      ```ts theme={null}
      new PrivateLocation("secure-proxy-location", {
        name: "Secure Corporate Proxy",
        slugName: "secure-corporate-proxy",
        proxyUrl: "https://secure-proxy.company.local:8443"
      })
      ```
    </Tab>

    <Tab title="Authenticated Proxy">
      ```ts theme={null}
      new PrivateLocation("auth-proxy-location", {
        name: "Authenticated Proxy Location",
        slugName: "authenticated-proxy",
        proxyUrl: "http://user:password@proxy.company.local:8080"
      })
      ```
    </Tab>
  </Tabs>

  <Info>
    When `proxyUrl` is configured, all HTTP calls from API checks running in this private location will route through the specified proxy server.
  </Info>

  **Use cases**: Corporate network compliance, security requirements, traffic routing control.
</ResponseField>

## Examples

<Tabs>
  <Tab title="Corporate VPC">
    ```ts theme={null}
    import { PrivateLocation, ApiCheck } from "checkly/constructs"

    const corporateVpc = new PrivateLocation("corporate-vpc", {
      name: "Corporate VPC",
      icon: "shield",
      slugName: "corporate-vpc"
    })

    // Monitor internal services
    new ApiCheck("intranet-check", {
      name: "Corporate Intranet",
      privateLocations: [corporateVpc],
      request: {
        method: "GET",
        url: "https://intranet.company.local"
      }
    })

    new ApiCheck("ldap-health-check", {
      name: "LDAP Service Health",
      privateLocations: [corporateVpc],
      request: {
        method: "GET",
        url: "https://ldap-health.company.local/status"
      }
    })
    ```
  </Tab>

  <Tab title="Multiple Datacenters">
    ```ts theme={null}
    const eastDatacenter = new PrivateLocation("dc-east", {
      name: "East Coast Datacenter",
      icon: "server",
      slugName: "datacenter-east"
    })

    const westDatacenter = new PrivateLocation("dc-west", {
      name: "West Coast Datacenter",
      icon: "server",
      slugName: "datacenter-west"
    })

    const centralDatabase = new PrivateLocation("central-db", {
      name: "Central Database Location",
      icon: "database",
      slugName: "central-database"
    })

    // Monitor cross-datacenter connectivity
    new ApiCheck("east-west-connectivity", {
      name: "East-West Datacenter Connectivity",
      privateLocations: [eastDatacenter, westDatacenter],
      request: {
        method: "GET",
        url: "https://connectivity-test.internal/ping"
      }
    })

    // Database health check from central location
    new ApiCheck("database-health", {
      name: "Database Health Check",
      privateLocations: [centralDatabase],
      request: {
        method: "GET",
        url: "https://db-health.internal:5432/health"
      }
    })
    ```
  </Tab>

  <Tab title="Development Environments">
    ```ts theme={null}
    const devEnvironment = new PrivateLocation("dev-env", {
      name: "Development Environment",
      icon: "tools",
      slugName: "development-environment"
    })

    const stagingEnvironment = new PrivateLocation("staging-env", {
      name: "Staging Environment",
      icon: "staging",
      slugName: "staging-environment"
    })

    // Development API monitoring
    new ApiCheck("dev-api-check", {
      name: "Development API",
      privateLocations: [devEnvironment],
      request: {
        method: "GET",
        url: "https://dev-api.company.local/health"
      }
    })

    // Staging environment checks
    new ApiCheck("staging-integration-check", {
      name: "Staging Integration Test",
      privateLocations: [stagingEnvironment],
      request: {
        method: "POST",
        url: "https://staging-api.company.local/integration-test",
        body: JSON.stringify({ test: true })
      }
    })
    ```
  </Tab>

  <Tab title="With Proxy Configuration">
    ```ts theme={null}
    const corporateLocation = new PrivateLocation("corporate-with-proxy", {
      name: "Corporate Network with Proxy",
      icon: "shield-lock",
      slugName: "corporate-with-proxy",
      proxyUrl: "http://proxy.company.local:8080"
    })

    // All API Check HTTP calls from this location will go through the proxy
    new ApiCheck("proxied-external-check", {
      name: "External API via Corporate Proxy",
      privateLocations: [corporateLocation],
      request: {
        method: "GET",
        url: "https://api.external-service.com/health"
      }
    })
    ```
  </Tab>
</Tabs>