1. Registry
  2. Packages
  3. Netbox Provider
  4. API Docs
  5. VirtualCircuitTermination
Viewing docs for netbox 6.0.1
published on Monday, Nov 16, 2026 by e-breuninger
netbox
Viewing docs for netbox 6.0.1
published on Monday, Nov 16, 2026 by e-breuninger

    Termination of a virtual circuit on an interface (circuits.virtualcircuittermination).

    From the official documentation:

    This model represents the connection of a virtual interface to a virtual circuit.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as netbox from "@pulumi/netbox";
    
    const test = new netbox.Site("test", {name: "test-site"});
    const testManufacturer = new netbox.Manufacturer("test", {name: "test-manufacturer"});
    const testDeviceType = new netbox.DeviceType("test", {
        manufacturerId: testManufacturer.manufacturerId,
        model: "test-device-type",
    });
    const testDeviceRole = new netbox.DeviceRole("test", {name: "test-device-role"});
    const testDevice = new netbox.Device("test", {
        name: "test-device",
        deviceTypeId: testDeviceType.deviceTypeId,
        roleId: testDeviceRole.deviceRoleId,
        siteId: test.siteId,
    });
    // Virtual circuits terminate on virtual interfaces only.
    const testDeviceInterface = new netbox.DeviceInterface("test", {
        deviceId: testDevice.deviceId,
        name: "test-device-interface",
        type: "virtual",
    });
    const testCircuitProvider = new netbox.CircuitProvider("test", {name: "test-circuit-provider"});
    const testCircuitProviderNetwork = new netbox.CircuitProviderNetwork("test", {
        name: "test-circuit-provider-network",
        circuitProviderId: testCircuitProvider.circuitProviderId,
    });
    const testCircuitProviderAccount = new netbox.CircuitProviderAccount("test", {
        account: "test-account",
        circuitProviderId: testCircuitProvider.circuitProviderId,
    });
    const testVirtualCircuitType = new netbox.VirtualCircuitType("test", {name: "test-virtual-circuit-type"});
    const testVirtualCircuit = new netbox.VirtualCircuit("test", {
        cid: "test-cid",
        circuitProviderNetworkId: testCircuitProviderNetwork.circuitProviderNetworkId,
        virtualCircuitTypeId: testVirtualCircuitType.virtualCircuitTypeId,
    });
    const testVirtualCircuitTermination = new netbox.VirtualCircuitTermination("test", {
        virtualCircuitId: testVirtualCircuit.virtualCircuitId,
        deviceInterfaceId: testDeviceInterface.deviceInterfaceId,
        role: "hub",
        description: "test-description",
    });
    
    import pulumi
    import pulumi_netbox as netbox
    
    test = netbox.Site("test", name="test-site")
    test_manufacturer = netbox.Manufacturer("test", name="test-manufacturer")
    test_device_type = netbox.DeviceType("test",
        manufacturer_id=test_manufacturer.manufacturer_id,
        model="test-device-type")
    test_device_role = netbox.DeviceRole("test", name="test-device-role")
    test_device = netbox.Device("test",
        name="test-device",
        device_type_id=test_device_type.device_type_id,
        role_id=test_device_role.device_role_id,
        site_id=test.site_id)
    # Virtual circuits terminate on virtual interfaces only.
    test_device_interface = netbox.DeviceInterface("test",
        device_id=test_device.device_id,
        name="test-device-interface",
        type="virtual")
    test_circuit_provider = netbox.CircuitProvider("test", name="test-circuit-provider")
    test_circuit_provider_network = netbox.CircuitProviderNetwork("test",
        name="test-circuit-provider-network",
        circuit_provider_id=test_circuit_provider.circuit_provider_id)
    test_circuit_provider_account = netbox.CircuitProviderAccount("test",
        account="test-account",
        circuit_provider_id=test_circuit_provider.circuit_provider_id)
    test_virtual_circuit_type = netbox.VirtualCircuitType("test", name="test-virtual-circuit-type")
    test_virtual_circuit = netbox.VirtualCircuit("test",
        cid="test-cid",
        circuit_provider_network_id=test_circuit_provider_network.circuit_provider_network_id,
        virtual_circuit_type_id=test_virtual_circuit_type.virtual_circuit_type_id)
    test_virtual_circuit_termination = netbox.VirtualCircuitTermination("test",
        virtual_circuit_id=test_virtual_circuit.virtual_circuit_id,
        device_interface_id=test_device_interface.device_interface_id,
        role="hub",
        description="test-description")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-terraform-provider/sdks/go/netbox/v6/netbox"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		test, err := netbox.NewSite(ctx, "test", &netbox.SiteArgs{
    			Name: pulumi.String("test-site"),
    		})
    		if err != nil {
    			return err
    		}
    		testManufacturer, err := netbox.NewManufacturer(ctx, "test", &netbox.ManufacturerArgs{
    			Name: pulumi.String("test-manufacturer"),
    		})
    		if err != nil {
    			return err
    		}
    		testDeviceType, err := netbox.NewDeviceType(ctx, "test", &netbox.DeviceTypeArgs{
    			ManufacturerId: testManufacturer.ManufacturerId,
    			Model:          pulumi.String("test-device-type"),
    		})
    		if err != nil {
    			return err
    		}
    		testDeviceRole, err := netbox.NewDeviceRole(ctx, "test", &netbox.DeviceRoleArgs{
    			Name: pulumi.String("test-device-role"),
    		})
    		if err != nil {
    			return err
    		}
    		testDevice, err := netbox.NewDevice(ctx, "test", &netbox.DeviceArgs{
    			Name:         pulumi.String("test-device"),
    			DeviceTypeId: testDeviceType.DeviceTypeId,
    			RoleId:       testDeviceRole.DeviceRoleId,
    			SiteId:       test.SiteId,
    		})
    		if err != nil {
    			return err
    		}
    		// Virtual circuits terminate on virtual interfaces only.
    		testDeviceInterface, err := netbox.NewDeviceInterface(ctx, "test", &netbox.DeviceInterfaceArgs{
    			DeviceId: testDevice.DeviceId,
    			Name:     pulumi.String("test-device-interface"),
    			Type:     pulumi.String("virtual"),
    		})
    		if err != nil {
    			return err
    		}
    		testCircuitProvider, err := netbox.NewCircuitProvider(ctx, "test", &netbox.CircuitProviderArgs{
    			Name: pulumi.String("test-circuit-provider"),
    		})
    		if err != nil {
    			return err
    		}
    		testCircuitProviderNetwork, err := netbox.NewCircuitProviderNetwork(ctx, "test", &netbox.CircuitProviderNetworkArgs{
    			Name:              pulumi.String("test-circuit-provider-network"),
    			CircuitProviderId: testCircuitProvider.CircuitProviderId,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = netbox.NewCircuitProviderAccount(ctx, "test", &netbox.CircuitProviderAccountArgs{
    			Account:           pulumi.String("test-account"),
    			CircuitProviderId: testCircuitProvider.CircuitProviderId,
    		})
    		if err != nil {
    			return err
    		}
    		testVirtualCircuitType, err := netbox.NewVirtualCircuitType(ctx, "test", &netbox.VirtualCircuitTypeArgs{
    			Name: pulumi.String("test-virtual-circuit-type"),
    		})
    		if err != nil {
    			return err
    		}
    		testVirtualCircuit, err := netbox.NewVirtualCircuit(ctx, "test", &netbox.VirtualCircuitArgs{
    			Cid:                      pulumi.String("test-cid"),
    			CircuitProviderNetworkId: testCircuitProviderNetwork.CircuitProviderNetworkId,
    			VirtualCircuitTypeId:     testVirtualCircuitType.VirtualCircuitTypeId,
    		})
    		if err != nil {
    			return err
    		}
    		_, err = netbox.NewVirtualCircuitTermination(ctx, "test", &netbox.VirtualCircuitTerminationArgs{
    			VirtualCircuitId:  testVirtualCircuit.VirtualCircuitId,
    			DeviceInterfaceId: testDeviceInterface.DeviceInterfaceId,
    			Role:              pulumi.String("hub"),
    			Description:       pulumi.String("test-description"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Netbox = Pulumi.Netbox;
    
    return await Deployment.RunAsync(() => 
    {
        var test = new Netbox.Site("test", new()
        {
            Name = "test-site",
        });
    
        var testManufacturer = new Netbox.Manufacturer("test", new()
        {
            Name = "test-manufacturer",
        });
    
        var testDeviceType = new Netbox.DeviceType("test", new()
        {
            ManufacturerId = testManufacturer.ManufacturerId,
            Model = "test-device-type",
        });
    
        var testDeviceRole = new Netbox.DeviceRole("test", new()
        {
            Name = "test-device-role",
        });
    
        var testDevice = new Netbox.Device("test", new()
        {
            Name = "test-device",
            DeviceTypeId = testDeviceType.DeviceTypeId,
            RoleId = testDeviceRole.DeviceRoleId,
            SiteId = test.SiteId,
        });
    
        // Virtual circuits terminate on virtual interfaces only.
        var testDeviceInterface = new Netbox.DeviceInterface("test", new()
        {
            DeviceId = testDevice.DeviceId,
            Name = "test-device-interface",
            Type = "virtual",
        });
    
        var testCircuitProvider = new Netbox.CircuitProvider("test", new()
        {
            Name = "test-circuit-provider",
        });
    
        var testCircuitProviderNetwork = new Netbox.CircuitProviderNetwork("test", new()
        {
            Name = "test-circuit-provider-network",
            CircuitProviderId = testCircuitProvider.CircuitProviderId,
        });
    
        var testCircuitProviderAccount = new Netbox.CircuitProviderAccount("test", new()
        {
            Account = "test-account",
            CircuitProviderId = testCircuitProvider.CircuitProviderId,
        });
    
        var testVirtualCircuitType = new Netbox.VirtualCircuitType("test", new()
        {
            Name = "test-virtual-circuit-type",
        });
    
        var testVirtualCircuit = new Netbox.VirtualCircuit("test", new()
        {
            Cid = "test-cid",
            CircuitProviderNetworkId = testCircuitProviderNetwork.CircuitProviderNetworkId,
            VirtualCircuitTypeId = testVirtualCircuitType.VirtualCircuitTypeId,
        });
    
        var testVirtualCircuitTermination = new Netbox.VirtualCircuitTermination("test", new()
        {
            VirtualCircuitId = testVirtualCircuit.VirtualCircuitId,
            DeviceInterfaceId = testDeviceInterface.DeviceInterfaceId,
            Role = "hub",
            Description = "test-description",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.netbox.Site;
    import com.pulumi.netbox.SiteArgs;
    import com.pulumi.netbox.Manufacturer;
    import com.pulumi.netbox.ManufacturerArgs;
    import com.pulumi.netbox.DeviceType;
    import com.pulumi.netbox.DeviceTypeArgs;
    import com.pulumi.netbox.DeviceRole;
    import com.pulumi.netbox.DeviceRoleArgs;
    import com.pulumi.netbox.Device;
    import com.pulumi.netbox.DeviceArgs;
    import com.pulumi.netbox.DeviceInterface;
    import com.pulumi.netbox.DeviceInterfaceArgs;
    import com.pulumi.netbox.CircuitProvider;
    import com.pulumi.netbox.CircuitProviderArgs;
    import com.pulumi.netbox.CircuitProviderNetwork;
    import com.pulumi.netbox.CircuitProviderNetworkArgs;
    import com.pulumi.netbox.CircuitProviderAccount;
    import com.pulumi.netbox.CircuitProviderAccountArgs;
    import com.pulumi.netbox.VirtualCircuitType;
    import com.pulumi.netbox.VirtualCircuitTypeArgs;
    import com.pulumi.netbox.VirtualCircuit;
    import com.pulumi.netbox.VirtualCircuitArgs;
    import com.pulumi.netbox.VirtualCircuitTermination;
    import com.pulumi.netbox.VirtualCircuitTerminationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var test = new Site("test", SiteArgs.builder()
                .name("test-site")
                .build());
    
            var testManufacturer = new Manufacturer("testManufacturer", ManufacturerArgs.builder()
                .name("test-manufacturer")
                .build());
    
            var testDeviceType = new DeviceType("testDeviceType", DeviceTypeArgs.builder()
                .manufacturerId(testManufacturer.manufacturerId())
                .model("test-device-type")
                .build());
    
            var testDeviceRole = new DeviceRole("testDeviceRole", DeviceRoleArgs.builder()
                .name("test-device-role")
                .build());
    
            var testDevice = new Device("testDevice", DeviceArgs.builder()
                .name("test-device")
                .deviceTypeId(testDeviceType.deviceTypeId())
                .roleId(testDeviceRole.deviceRoleId())
                .siteId(test.siteId())
                .build());
    
            // Virtual circuits terminate on virtual interfaces only.
            var testDeviceInterface = new DeviceInterface("testDeviceInterface", DeviceInterfaceArgs.builder()
                .deviceId(testDevice.deviceId())
                .name("test-device-interface")
                .type("virtual")
                .build());
    
            var testCircuitProvider = new CircuitProvider("testCircuitProvider", CircuitProviderArgs.builder()
                .name("test-circuit-provider")
                .build());
    
            var testCircuitProviderNetwork = new CircuitProviderNetwork("testCircuitProviderNetwork", CircuitProviderNetworkArgs.builder()
                .name("test-circuit-provider-network")
                .circuitProviderId(testCircuitProvider.circuitProviderId())
                .build());
    
            var testCircuitProviderAccount = new CircuitProviderAccount("testCircuitProviderAccount", CircuitProviderAccountArgs.builder()
                .account("test-account")
                .circuitProviderId(testCircuitProvider.circuitProviderId())
                .build());
    
            var testVirtualCircuitType = new VirtualCircuitType("testVirtualCircuitType", VirtualCircuitTypeArgs.builder()
                .name("test-virtual-circuit-type")
                .build());
    
            var testVirtualCircuit = new VirtualCircuit("testVirtualCircuit", VirtualCircuitArgs.builder()
                .cid("test-cid")
                .circuitProviderNetworkId(testCircuitProviderNetwork.circuitProviderNetworkId())
                .virtualCircuitTypeId(testVirtualCircuitType.virtualCircuitTypeId())
                .build());
    
            var testVirtualCircuitTermination = new VirtualCircuitTermination("testVirtualCircuitTermination", VirtualCircuitTerminationArgs.builder()
                .virtualCircuitId(testVirtualCircuit.virtualCircuitId())
                .deviceInterfaceId(testDeviceInterface.deviceInterfaceId())
                .role("hub")
                .description("test-description")
                .build());
    
        }
    }
    
    resources:
      test:
        type: netbox:Site
        properties:
          name: test-site
      testManufacturer:
        type: netbox:Manufacturer
        name: test
        properties:
          name: test-manufacturer
      testDeviceType:
        type: netbox:DeviceType
        name: test
        properties:
          manufacturerId: ${testManufacturer.manufacturerId}
          model: test-device-type
      testDeviceRole:
        type: netbox:DeviceRole
        name: test
        properties:
          name: test-device-role
      testDevice:
        type: netbox:Device
        name: test
        properties:
          name: test-device
          deviceTypeId: ${testDeviceType.deviceTypeId}
          roleId: ${testDeviceRole.deviceRoleId}
          siteId: ${test.siteId}
      # Virtual circuits terminate on virtual interfaces only.
      testDeviceInterface:
        type: netbox:DeviceInterface
        name: test
        properties:
          deviceId: ${testDevice.deviceId}
          name: test-device-interface
          type: virtual
      testCircuitProvider:
        type: netbox:CircuitProvider
        name: test
        properties:
          name: test-circuit-provider
      testCircuitProviderNetwork:
        type: netbox:CircuitProviderNetwork
        name: test
        properties:
          name: test-circuit-provider-network
          circuitProviderId: ${testCircuitProvider.circuitProviderId}
      testCircuitProviderAccount:
        type: netbox:CircuitProviderAccount
        name: test
        properties:
          account: test-account
          circuitProviderId: ${testCircuitProvider.circuitProviderId}
      testVirtualCircuitType:
        type: netbox:VirtualCircuitType
        name: test
        properties:
          name: test-virtual-circuit-type
      testVirtualCircuit:
        type: netbox:VirtualCircuit
        name: test
        properties:
          cid: test-cid
          circuitProviderNetworkId: ${testCircuitProviderNetwork.circuitProviderNetworkId}
          virtualCircuitTypeId: ${testVirtualCircuitType.virtualCircuitTypeId}
      testVirtualCircuitTermination:
        type: netbox:VirtualCircuitTermination
        name: test
        properties:
          virtualCircuitId: ${testVirtualCircuit.virtualCircuitId}
          deviceInterfaceId: ${testDeviceInterface.deviceInterfaceId}
          role: hub
          description: test-description
    
    Example coming soon!
    

    Create VirtualCircuitTermination Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new VirtualCircuitTermination(name: string, args: VirtualCircuitTerminationArgs, opts?: CustomResourceOptions);
    @overload
    def VirtualCircuitTermination(resource_name: str,
                                  args: VirtualCircuitTerminationArgs,
                                  opts: Optional[ResourceOptions] = None)
    
    @overload
    def VirtualCircuitTermination(resource_name: str,
                                  opts: Optional[ResourceOptions] = None,
                                  device_interface_id: Optional[float] = None,
                                  virtual_circuit_id: Optional[float] = None,
                                  custom_fields: Optional[Mapping[str, str]] = None,
                                  description: Optional[str] = None,
                                  role: Optional[str] = None,
                                  tags: Optional[Sequence[str]] = None)
    func NewVirtualCircuitTermination(ctx *Context, name string, args VirtualCircuitTerminationArgs, opts ...ResourceOption) (*VirtualCircuitTermination, error)
    public VirtualCircuitTermination(string name, VirtualCircuitTerminationArgs args, CustomResourceOptions? opts = null)
    public VirtualCircuitTermination(String name, VirtualCircuitTerminationArgs args)
    public VirtualCircuitTermination(String name, VirtualCircuitTerminationArgs args, CustomResourceOptions options)
    
    type: netbox:VirtualCircuitTermination
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    resource "netbox_virtual_circuit_termination" "name" {
        # resource properties
    }

    Parameters

    name string
    The unique name of the resource.
    args VirtualCircuitTerminationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args VirtualCircuitTerminationArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args VirtualCircuitTerminationArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args VirtualCircuitTerminationArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args VirtualCircuitTerminationArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var virtualCircuitTerminationResource = new Netbox.VirtualCircuitTermination("virtualCircuitTerminationResource", new()
    {
        DeviceInterfaceId = 0.0,
        VirtualCircuitId = 0.0,
        CustomFields = 
        {
            { "string", "string" },
        },
        Description = "string",
        Role = "string",
        Tags = new[]
        {
            "string",
        },
    });
    
    example, err := netbox.NewVirtualCircuitTermination(ctx, "virtualCircuitTerminationResource", &netbox.VirtualCircuitTerminationArgs{
    	DeviceInterfaceId: pulumi.Float64(0),
    	VirtualCircuitId:  pulumi.Float64(0),
    	CustomFields: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	Description: pulumi.String("string"),
    	Role:        pulumi.String("string"),
    	Tags: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    })
    
    resource "netbox_virtual_circuit_termination" "virtualCircuitTerminationResource" {
      lifecycle {
        create_before_destroy = true
      }
      device_interface_id = 0
      virtual_circuit_id  = 0
      custom_fields = {
        "string" = "string"
      }
      description = "string"
      role        = "string"
      tags        = ["string"]
    }
    
    var virtualCircuitTerminationResource = new VirtualCircuitTermination("virtualCircuitTerminationResource", VirtualCircuitTerminationArgs.builder()
        .deviceInterfaceId(0.0)
        .virtualCircuitId(0.0)
        .customFields(Map.of("string", "string"))
        .description("string")
        .role("string")
        .tags("string")
        .build());
    
    virtual_circuit_termination_resource = netbox.VirtualCircuitTermination("virtualCircuitTerminationResource",
        device_interface_id=float(0),
        virtual_circuit_id=float(0),
        custom_fields={
            "string": "string",
        },
        description="string",
        role="string",
        tags=["string"])
    
    const virtualCircuitTerminationResource = new netbox.VirtualCircuitTermination("virtualCircuitTerminationResource", {
        deviceInterfaceId: 0,
        virtualCircuitId: 0,
        customFields: {
            string: "string",
        },
        description: "string",
        role: "string",
        tags: ["string"],
    });
    
    type: netbox:VirtualCircuitTermination
    properties:
        customFields:
            string: string
        description: string
        deviceInterfaceId: 0
        role: string
        tags:
            - string
        virtualCircuitId: 0
    

    VirtualCircuitTermination Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The VirtualCircuitTermination resource accepts the following input properties:

    DeviceInterfaceId double
    Id of the device interface the virtual circuit terminates on.
    VirtualCircuitId double
    Id of the terminated virtual circuit.
    CustomFields Dictionary<string, string>
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    Description string
    Role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    Tags List<string>
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    DeviceInterfaceId float64
    Id of the device interface the virtual circuit terminates on.
    VirtualCircuitId float64
    Id of the terminated virtual circuit.
    CustomFields map[string]string
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    Description string
    Role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    Tags []string
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    device_interface_id number
    Id of the device interface the virtual circuit terminates on.
    virtual_circuit_id number
    Id of the terminated virtual circuit.
    custom_fields map(string)
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description string
    role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags list(string)
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    deviceInterfaceId Double
    Id of the device interface the virtual circuit terminates on.
    virtualCircuitId Double
    Id of the terminated virtual circuit.
    customFields Map<String,String>
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description String
    role String
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags List<String>
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    deviceInterfaceId number
    Id of the device interface the virtual circuit terminates on.
    virtualCircuitId number
    Id of the terminated virtual circuit.
    customFields {[key: string]: string}
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description string
    role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags string[]
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    device_interface_id float
    Id of the device interface the virtual circuit terminates on.
    virtual_circuit_id float
    Id of the terminated virtual circuit.
    custom_fields Mapping[str, str]
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description str
    role str
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags Sequence[str]
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    deviceInterfaceId Number
    Id of the device interface the virtual circuit terminates on.
    virtualCircuitId Number
    Id of the terminated virtual circuit.
    customFields Map<String>
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description String
    role String
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags List<String>
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).

    Outputs

    All input properties are implicitly available as output properties. Additionally, the VirtualCircuitTermination resource produces the following output properties:

    Created string
    Id string
    The provider-assigned unique ID for this managed resource.
    LastUpdated string
    TagsAlls List<string>
    Slugs of all tags on the object, including the provider's default_tags.
    Url string
    VirtualCircuitTerminationId double
    NetBox id.
    Created string
    Id string
    The provider-assigned unique ID for this managed resource.
    LastUpdated string
    TagsAlls []string
    Slugs of all tags on the object, including the provider's default_tags.
    Url string
    VirtualCircuitTerminationId float64
    NetBox id.
    created string
    id string
    The provider-assigned unique ID for this managed resource.
    last_updated string
    tags_alls list(string)
    Slugs of all tags on the object, including the provider's default_tags.
    url string
    virtual_circuit_termination_id number
    NetBox id.
    created String
    id String
    The provider-assigned unique ID for this managed resource.
    lastUpdated String
    tagsAlls List<String>
    Slugs of all tags on the object, including the provider's default_tags.
    url String
    virtualCircuitTerminationId Double
    NetBox id.
    created string
    id string
    The provider-assigned unique ID for this managed resource.
    lastUpdated string
    tagsAlls string[]
    Slugs of all tags on the object, including the provider's default_tags.
    url string
    virtualCircuitTerminationId number
    NetBox id.
    created str
    id str
    The provider-assigned unique ID for this managed resource.
    last_updated str
    tags_alls Sequence[str]
    Slugs of all tags on the object, including the provider's default_tags.
    url str
    virtual_circuit_termination_id float
    NetBox id.
    created String
    id String
    The provider-assigned unique ID for this managed resource.
    lastUpdated String
    tagsAlls List<String>
    Slugs of all tags on the object, including the provider's default_tags.
    url String
    virtualCircuitTerminationId Number
    NetBox id.

    Look up Existing VirtualCircuitTermination Resource

    Get an existing VirtualCircuitTermination resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: VirtualCircuitTerminationState, opts?: CustomResourceOptions): VirtualCircuitTermination
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            created: Optional[str] = None,
            custom_fields: Optional[Mapping[str, str]] = None,
            description: Optional[str] = None,
            device_interface_id: Optional[float] = None,
            last_updated: Optional[str] = None,
            role: Optional[str] = None,
            tags: Optional[Sequence[str]] = None,
            tags_alls: Optional[Sequence[str]] = None,
            url: Optional[str] = None,
            virtual_circuit_id: Optional[float] = None,
            virtual_circuit_termination_id: Optional[float] = None) -> VirtualCircuitTermination
    func GetVirtualCircuitTermination(ctx *Context, name string, id IDInput, state *VirtualCircuitTerminationState, opts ...ResourceOption) (*VirtualCircuitTermination, error)
    public static VirtualCircuitTermination Get(string name, Input<string> id, VirtualCircuitTerminationState? state, CustomResourceOptions? opts = null)
    public static VirtualCircuitTermination get(String name, Output<String> id, VirtualCircuitTerminationState state, CustomResourceOptions options)
    resources:  existingVirtualCircuitTermination:    type: netbox:VirtualCircuitTermination    get:      id: ${id}
    import {
      to = netbox_virtual_circuit_termination.example
      id = "${id}"
    }
    
    name string
    The unique name of the resulting resource.
    id Input<ID>
    The unique provider ID of the resource to look up.
    state VirtualCircuitTerminationState
    Known property values the provider needs, along with the ID, to find the resource. Usually not required.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resulting resource.
    id str
    The unique provider ID of the resource to look up.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resulting resource.
    id IDInput
    The unique provider ID of the resource to look up.
    state VirtualCircuitTerminationState
    Known property values the provider needs, along with the ID, to find the resource. Usually not required.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resulting resource.
    id Input<string>
    The unique provider ID of the resource to look up.
    state VirtualCircuitTerminationState
    Known property values the provider needs, along with the ID, to find the resource. Usually not required.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resulting resource.
    id Output<String>
    The unique provider ID of the resource to look up.
    state VirtualCircuitTerminationState
    Known property values the provider needs, along with the ID, to find the resource. Usually not required.
    options CustomResourceOptions
    Bag of options to control resource's behavior.
    The following state arguments are supported:
    Created string
    CustomFields Dictionary<string, string>
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    Description string
    DeviceInterfaceId double
    Id of the device interface the virtual circuit terminates on.
    LastUpdated string
    Role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    Tags List<string>
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    TagsAlls List<string>
    Slugs of all tags on the object, including the provider's default_tags.
    Url string
    VirtualCircuitId double
    Id of the terminated virtual circuit.
    VirtualCircuitTerminationId double
    NetBox id.
    Created string
    CustomFields map[string]string
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    Description string
    DeviceInterfaceId float64
    Id of the device interface the virtual circuit terminates on.
    LastUpdated string
    Role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    Tags []string
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    TagsAlls []string
    Slugs of all tags on the object, including the provider's default_tags.
    Url string
    VirtualCircuitId float64
    Id of the terminated virtual circuit.
    VirtualCircuitTerminationId float64
    NetBox id.
    created string
    custom_fields map(string)
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description string
    device_interface_id number
    Id of the device interface the virtual circuit terminates on.
    last_updated string
    role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags list(string)
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    tags_alls list(string)
    Slugs of all tags on the object, including the provider's default_tags.
    url string
    virtual_circuit_id number
    Id of the terminated virtual circuit.
    virtual_circuit_termination_id number
    NetBox id.
    created String
    customFields Map<String,String>
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description String
    deviceInterfaceId Double
    Id of the device interface the virtual circuit terminates on.
    lastUpdated String
    role String
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags List<String>
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    tagsAlls List<String>
    Slugs of all tags on the object, including the provider's default_tags.
    url String
    virtualCircuitId Double
    Id of the terminated virtual circuit.
    virtualCircuitTerminationId Double
    NetBox id.
    created string
    customFields {[key: string]: string}
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description string
    deviceInterfaceId number
    Id of the device interface the virtual circuit terminates on.
    lastUpdated string
    role string
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags string[]
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    tagsAlls string[]
    Slugs of all tags on the object, including the provider's default_tags.
    url string
    virtualCircuitId number
    Id of the terminated virtual circuit.
    virtualCircuitTerminationId number
    NetBox id.
    created str
    custom_fields Mapping[str, str]
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description str
    device_interface_id float
    Id of the device interface the virtual circuit terminates on.
    last_updated str
    role str
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags Sequence[str]
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    tags_alls Sequence[str]
    Slugs of all tags on the object, including the provider's default_tags.
    url str
    virtual_circuit_id float
    Id of the terminated virtual circuit.
    virtual_circuit_termination_id float
    NetBox id.
    created String
    customFields Map<String>
    Custom field values by field name. Every value is a string; NetBox coerces numbers and booleans. An object field holds the related object's id, e.g. "12", a multiobject field a JSON list of ids in any order, e.g. jsonencode([12, 13]). A key removed from the map is cleared in NetBox (set {} to clear all).
    description String
    deviceInterfaceId Number
    Id of the device interface the virtual circuit terminates on.
    lastUpdated String
    role String
    Role of this termination in the virtual circuit. Leaving it unset keeps the current value. One of: peer, hub, spoke.
    tags List<String>
    Slugs of the tags assigned to the object (the provider's defaulttags are added on top, see tagsall).
    tagsAlls List<String>
    Slugs of all tags on the object, including the provider's default_tags.
    url String
    virtualCircuitId Number
    Id of the terminated virtual circuit.
    virtualCircuitTerminationId Number
    NetBox id.

    Import

    In Terraform v1.5.0 and later, the import block can be used with the id attribute, for example:

    terraform

    import {

    to = netbox_virtual_circuit_termination.test

    id = “123”

    }

    The pulumi import command can be used, for example:

    $ pulumi import netbox:index/virtualCircuitTermination:VirtualCircuitTermination test 123
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    netbox e-breuninger/terraform-provider-netbox
    License
    Notes
    This Pulumi package is based on the netbox Terraform Provider.
    netbox
    Viewing docs for netbox 6.0.1
    published on Monday, Nov 16, 2026 by e-breuninger

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial