diff --git a/netbox/circuits/tests/test_api.py b/netbox/circuits/tests/test_api.py
index 0a9ef0ab6..1228aafaa 100644
--- a/netbox/circuits/tests/test_api.py
+++ b/netbox/circuits/tests/test_api.py
@@ -77,6 +77,32 @@ class ProviderTest(HttpStatusMixin, APITestCase):
         self.assertEqual(provider4.name, data['name'])
         self.assertEqual(provider4.slug, data['slug'])
 
+    def test_create_provider_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Provider 4',
+                'slug': 'test-provider-4',
+            },
+            {
+                'name': 'Test Provider 5',
+                'slug': 'test-provider-5',
+            },
+            {
+                'name': 'Test Provider 6',
+                'slug': 'test-provider-6',
+            },
+        ]
+
+        url = reverse('circuits-api:provider-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Provider.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_provider(self):
 
         data = {
@@ -217,6 +243,35 @@ class CircuitTest(HttpStatusMixin, APITestCase):
         self.assertEqual(circuit4.provider_id, data['provider'])
         self.assertEqual(circuit4.type_id, data['type'])
 
+    def test_create_circuit_bulk(self):
+
+        data = [
+            {
+                'cid': 'TEST0004',
+                'provider': self.provider1.pk,
+                'type': self.circuittype1.pk,
+            },
+            {
+                'cid': 'TEST0005',
+                'provider': self.provider1.pk,
+                'type': self.circuittype1.pk,
+            },
+            {
+                'cid': 'TEST0006',
+                'provider': self.provider1.pk,
+                'type': self.circuittype1.pk,
+            },
+        ]
+
+        url = reverse('circuits-api:circuit-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Circuit.objects.count(), 6)
+        self.assertEqual(response.data[0]['cid'], data[0]['cid'])
+        self.assertEqual(response.data[1]['cid'], data[1]['cid'])
+        self.assertEqual(response.data[2]['cid'], data[2]['cid'])
+
     def test_update_circuit(self):
 
         data = {
diff --git a/netbox/dcim/tests/test_api.py b/netbox/dcim/tests/test_api.py
index 2d096244f..7c4a01c15 100644
--- a/netbox/dcim/tests/test_api.py
+++ b/netbox/dcim/tests/test_api.py
@@ -59,6 +59,32 @@ class RegionTest(HttpStatusMixin, APITestCase):
         self.assertEqual(region4.name, data['name'])
         self.assertEqual(region4.slug, data['slug'])
 
+    def test_create_region_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Region 4',
+                'slug': 'test-region-4',
+            },
+            {
+                'name': 'Test Region 5',
+                'slug': 'test-region-5',
+            },
+            {
+                'name': 'Test Region 6',
+                'slug': 'test-region-6',
+            },
+        ]
+
+        url = reverse('dcim-api:region-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Region.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_region(self):
 
         data = {
@@ -151,6 +177,35 @@ class SiteTest(HttpStatusMixin, APITestCase):
         self.assertEqual(site4.slug, data['slug'])
         self.assertEqual(site4.region_id, data['region'])
 
+    def test_create_site_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Site 4',
+                'slug': 'test-site-4',
+                'region': self.region1.pk,
+            },
+            {
+                'name': 'Test Site 5',
+                'slug': 'test-site-5',
+                'region': self.region1.pk,
+            },
+            {
+                'name': 'Test Site 6',
+                'slug': 'test-site-6',
+                'region': self.region1.pk,
+            },
+        ]
+
+        url = reverse('dcim-api:site-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Site.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_site(self):
 
         data = {
@@ -224,6 +279,35 @@ class RackGroupTest(HttpStatusMixin, APITestCase):
         self.assertEqual(rackgroup4.slug, data['slug'])
         self.assertEqual(rackgroup4.site_id, data['site'])
 
+    def test_create_rackgroup_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Rack Group 4',
+                'slug': 'test-rack-group-4',
+                'site': self.site1.pk,
+            },
+            {
+                'name': 'Test Rack Group 5',
+                'slug': 'test-rack-group-5',
+                'site': self.site1.pk,
+            },
+            {
+                'name': 'Test Rack Group 6',
+                'slug': 'test-rack-group-6',
+                'site': self.site1.pk,
+            },
+        ]
+
+        url = reverse('dcim-api:rackgroup-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(RackGroup.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_rackgroup(self):
 
         data = {
@@ -295,6 +379,35 @@ class RackRoleTest(HttpStatusMixin, APITestCase):
         self.assertEqual(rackrole1.slug, data['slug'])
         self.assertEqual(rackrole1.color, data['color'])
 
+    def test_create_rackrole_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Rack Role 4',
+                'slug': 'test-rack-role-4',
+                'color': 'ffff00',
+            },
+            {
+                'name': 'Test Rack Role 5',
+                'slug': 'test-rack-role-5',
+                'color': 'ffff00',
+            },
+            {
+                'name': 'Test Rack Role 6',
+                'slug': 'test-rack-role-6',
+                'color': 'ffff00',
+            },
+        ]
+
+        url = reverse('dcim-api:rackrole-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(RackRole.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_rackrole(self):
 
         data = {
@@ -387,6 +500,38 @@ class RackTest(HttpStatusMixin, APITestCase):
         self.assertEqual(rack4.group_id, data['group'])
         self.assertEqual(rack4.role_id, data['role'])
 
+    def test_create_rack_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Rack 4',
+                'site': self.site1.pk,
+                'group': self.rackgroup1.pk,
+                'role': self.rackrole1.pk,
+            },
+            {
+                'name': 'Test Rack 5',
+                'site': self.site1.pk,
+                'group': self.rackgroup1.pk,
+                'role': self.rackrole1.pk,
+            },
+            {
+                'name': 'Test Rack 6',
+                'site': self.site1.pk,
+                'group': self.rackgroup1.pk,
+                'role': self.rackrole1.pk,
+            },
+        ]
+
+        url = reverse('dcim-api:rack-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Rack.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_rack(self):
 
         data = {
@@ -428,13 +573,13 @@ class RackReservationTest(HttpStatusMixin, APITestCase):
         self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
         self.rack1 = Rack.objects.create(site=self.site1, name='Test Rack 1')
         self.rackreservation1 = RackReservation.objects.create(
-            rack=self.rack1, units=[1, 2, 3], user=user, description='First reservation',
+            rack=self.rack1, units=[1, 2, 3], user=user, description='Reservation #1',
         )
         self.rackreservation2 = RackReservation.objects.create(
-            rack=self.rack1, units=[4, 5, 6], user=user, description='Second reservation',
+            rack=self.rack1, units=[4, 5, 6], user=user, description='Reservation #2',
         )
         self.rackreservation3 = RackReservation.objects.create(
-            rack=self.rack1, units=[7, 8, 9], user=user, description='Third reservation',
+            rack=self.rack1, units=[7, 8, 9], user=user, description='Reservation #3',
         )
 
     def test_get_rackreservation(self):
@@ -471,6 +616,38 @@ class RackReservationTest(HttpStatusMixin, APITestCase):
         self.assertEqual(rackreservation4.user_id, data['user'])
         self.assertEqual(rackreservation4.description, data['description'])
 
+    def test_create_rackreservation_bulk(self):
+
+        data = [
+            {
+                'rack': self.rack1.pk,
+                'units': [10, 11, 12],
+                'user': self.user1.pk,
+                'description': 'Reservation #4',
+            },
+            {
+                'rack': self.rack1.pk,
+                'units': [13, 14, 15],
+                'user': self.user1.pk,
+                'description': 'Reservation #5',
+            },
+            {
+                'rack': self.rack1.pk,
+                'units': [16, 17, 18],
+                'user': self.user1.pk,
+                'description': 'Reservation #6',
+            },
+        ]
+
+        url = reverse('dcim-api:rackreservation-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(RackReservation.objects.count(), 6)
+        self.assertEqual(response.data[0]['description'], data[0]['description'])
+        self.assertEqual(response.data[1]['description'], data[1]['description'])
+        self.assertEqual(response.data[2]['description'], data[2]['description'])
+
     def test_update_rackreservation(self):
 
         data = {
@@ -540,6 +717,32 @@ class ManufacturerTest(HttpStatusMixin, APITestCase):
         self.assertEqual(manufacturer4.name, data['name'])
         self.assertEqual(manufacturer4.slug, data['slug'])
 
+    def test_create_manufacturer_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Manufacturer 4',
+                'slug': 'test-manufacturer-4',
+            },
+            {
+                'name': 'Test Manufacturer 5',
+                'slug': 'test-manufacturer-5',
+            },
+            {
+                'name': 'Test Manufacturer 6',
+                'slug': 'test-manufacturer-6',
+            },
+        ]
+
+        url = reverse('dcim-api:manufacturer-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Manufacturer.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_manufacturer(self):
 
         data = {
@@ -617,6 +820,35 @@ class DeviceTypeTest(HttpStatusMixin, APITestCase):
         self.assertEqual(devicetype4.model, data['model'])
         self.assertEqual(devicetype4.slug, data['slug'])
 
+    def test_create_devicetype_bulk(self):
+
+        data = [
+            {
+                'manufacturer': self.manufacturer1.pk,
+                'model': 'Test Device Type 4',
+                'slug': 'test-device-type-4',
+            },
+            {
+                'manufacturer': self.manufacturer1.pk,
+                'model': 'Test Device Type 5',
+                'slug': 'test-device-type-5',
+            },
+            {
+                'manufacturer': self.manufacturer1.pk,
+                'model': 'Test Device Type 6',
+                'slug': 'test-device-type-6',
+            },
+        ]
+
+        url = reverse('dcim-api:devicetype-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(DeviceType.objects.count(), 6)
+        self.assertEqual(response.data[0]['model'], data[0]['model'])
+        self.assertEqual(response.data[1]['model'], data[1]['model'])
+        self.assertEqual(response.data[2]['model'], data[2]['model'])
+
     def test_update_devicetype(self):
 
         data = {
@@ -696,6 +928,32 @@ class ConsolePortTemplateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(consoleporttemplate4.device_type_id, data['device_type'])
         self.assertEqual(consoleporttemplate4.name, data['name'])
 
+    def test_create_consoleporttemplate_bulk(self):
+
+        data = [
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test CP Template 4',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test CP Template 5',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test CP Template 6',
+            },
+        ]
+
+        url = reverse('dcim-api:consoleporttemplate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(ConsolePortTemplate.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_consoleporttemplate(self):
 
         data = {
@@ -772,6 +1030,32 @@ class ConsoleServerPortTemplateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(consoleserverporttemplate4.device_type_id, data['device_type'])
         self.assertEqual(consoleserverporttemplate4.name, data['name'])
 
+    def test_create_consoleserverporttemplate_bulk(self):
+
+        data = [
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test CSP Template 4',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test CSP Template 5',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test CSP Template 6',
+            },
+        ]
+
+        url = reverse('dcim-api:consoleserverporttemplate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(ConsoleServerPortTemplate.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_consoleserverporttemplate(self):
 
         data = {
@@ -848,6 +1132,32 @@ class PowerPortTemplateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(powerporttemplate4.device_type_id, data['device_type'])
         self.assertEqual(powerporttemplate4.name, data['name'])
 
+    def test_create_powerporttemplate_bulk(self):
+
+        data = [
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test PP Template 4',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test PP Template 5',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test PP Template 6',
+            },
+        ]
+
+        url = reverse('dcim-api:powerporttemplate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(PowerPortTemplate.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_powerporttemplate(self):
 
         data = {
@@ -924,6 +1234,32 @@ class PowerOutletTemplateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(poweroutlettemplate4.device_type_id, data['device_type'])
         self.assertEqual(poweroutlettemplate4.name, data['name'])
 
+    def test_create_poweroutlettemplate_bulk(self):
+
+        data = [
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test PO Template 4',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test PO Template 5',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test PO Template 6',
+            },
+        ]
+
+        url = reverse('dcim-api:poweroutlettemplate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(PowerOutletTemplate.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_poweroutlettemplate(self):
 
         data = {
@@ -1000,6 +1336,32 @@ class InterfaceTemplateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(interfacetemplate4.device_type_id, data['device_type'])
         self.assertEqual(interfacetemplate4.name, data['name'])
 
+    def test_create_interfacetemplate_bulk(self):
+
+        data = [
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test Interface Template 4',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test Interface Template 5',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test Interface Template 6',
+            },
+        ]
+
+        url = reverse('dcim-api:interfacetemplate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(InterfaceTemplate.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_interfacetemplate(self):
 
         data = {
@@ -1076,6 +1438,32 @@ class DeviceBayTemplateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(devicebaytemplate4.device_type_id, data['device_type'])
         self.assertEqual(devicebaytemplate4.name, data['name'])
 
+    def test_create_devicebaytemplate_bulk(self):
+
+        data = [
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test Device Bay Template 4',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test Device Bay Template 5',
+            },
+            {
+                'device_type': self.devicetype.pk,
+                'name': 'Test Device Bay Template 6',
+            },
+        ]
+
+        url = reverse('dcim-api:devicebaytemplate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(DeviceBayTemplate.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_devicebaytemplate(self):
 
         data = {
@@ -1150,6 +1538,35 @@ class DeviceRoleTest(HttpStatusMixin, APITestCase):
         self.assertEqual(devicerole4.slug, data['slug'])
         self.assertEqual(devicerole4.color, data['color'])
 
+    def test_create_devicerole_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Device Role 4',
+                'slug': 'test-device-role-4',
+                'color': 'ffff00',
+            },
+            {
+                'name': 'Test Device Role 5',
+                'slug': 'test-device-role-5',
+                'color': 'ffff00',
+            },
+            {
+                'name': 'Test Device Role 6',
+                'slug': 'test-device-role-6',
+                'color': 'ffff00',
+            },
+        ]
+
+        url = reverse('dcim-api:devicerole-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(DeviceRole.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_devicerole(self):
 
         data = {
@@ -1219,6 +1636,32 @@ class PlatformTest(HttpStatusMixin, APITestCase):
         self.assertEqual(platform4.name, data['name'])
         self.assertEqual(platform4.slug, data['slug'])
 
+    def test_create_platform_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Platform 4',
+                'slug': 'test-platform-4',
+            },
+            {
+                'name': 'Test Platform 5',
+                'slug': 'test-platform-5',
+            },
+            {
+                'name': 'Test Platform 6',
+                'slug': 'test-platform-6',
+            },
+        ]
+
+        url = reverse('dcim-api:platform-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Platform.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_platform(self):
 
         data = {
@@ -1311,6 +1754,38 @@ class DeviceTest(HttpStatusMixin, APITestCase):
         self.assertEqual(device4.name, data['name'])
         self.assertEqual(device4.site_id, data['site'])
 
+    def test_create_device_bulk(self):
+
+        data = [
+            {
+                'device_type': self.devicetype1.pk,
+                'device_role': self.devicerole1.pk,
+                'name': 'Test Device 4',
+                'site': self.site1.pk,
+            },
+            {
+                'device_type': self.devicetype1.pk,
+                'device_role': self.devicerole1.pk,
+                'name': 'Test Device 5',
+                'site': self.site1.pk,
+            },
+            {
+                'device_type': self.devicetype1.pk,
+                'device_role': self.devicerole1.pk,
+                'name': 'Test Device 6',
+                'site': self.site1.pk,
+            },
+        ]
+
+        url = reverse('dcim-api:device-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Device.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_device(self):
 
         data = {
@@ -1393,6 +1868,32 @@ class ConsolePortTest(HttpStatusMixin, APITestCase):
         self.assertEqual(consoleport4.device_id, data['device'])
         self.assertEqual(consoleport4.name, data['name'])
 
+    def test_create_consoleport_bulk(self):
+
+        data = [
+            {
+                'device': self.device.pk,
+                'name': 'Test Console Port 4',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Console Port 5',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Console Port 6',
+            },
+        ]
+
+        url = reverse('dcim-api:consoleport-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(ConsolePort.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_consoleport(self):
 
         consoleserverport = ConsoleServerPort.objects.create(device=self.device, name='Test CS Port 1')
@@ -1474,6 +1975,32 @@ class ConsoleServerPortTest(HttpStatusMixin, APITestCase):
         self.assertEqual(consoleserverport4.device_id, data['device'])
         self.assertEqual(consoleserverport4.name, data['name'])
 
+    def test_create_consoleserverport_bulk(self):
+
+        data = [
+            {
+                'device': self.device.pk,
+                'name': 'Test CS Port 4',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test CS Port 5',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test CS Port 6',
+            },
+        ]
+
+        url = reverse('dcim-api:consoleserverport-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(ConsoleServerPort.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_consoleserverport(self):
 
         data = {
@@ -1551,6 +2078,32 @@ class PowerPortTest(HttpStatusMixin, APITestCase):
         self.assertEqual(powerport4.device_id, data['device'])
         self.assertEqual(powerport4.name, data['name'])
 
+    def test_create_powerport_bulk(self):
+
+        data = [
+            {
+                'device': self.device.pk,
+                'name': 'Test Power Port 4',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Power Port 5',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Power Port 6',
+            },
+        ]
+
+        url = reverse('dcim-api:powerport-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(PowerPort.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_powerport(self):
 
         poweroutlet = PowerOutlet.objects.create(device=self.device, name='Test Power Outlet 1')
@@ -1632,6 +2185,32 @@ class PowerOutletTest(HttpStatusMixin, APITestCase):
         self.assertEqual(poweroutlet4.device_id, data['device'])
         self.assertEqual(poweroutlet4.name, data['name'])
 
+    def test_create_poweroutlet_bulk(self):
+
+        data = [
+            {
+                'device': self.device.pk,
+                'name': 'Test Power Outlet 4',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Power Outlet 5',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Power Outlet 6',
+            },
+        ]
+
+        url = reverse('dcim-api:poweroutlet-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(PowerOutlet.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_poweroutlet(self):
 
         data = {
@@ -1730,6 +2309,32 @@ class InterfaceTest(HttpStatusMixin, APITestCase):
         self.assertEqual(interface4.device_id, data['device'])
         self.assertEqual(interface4.name, data['name'])
 
+    def test_create_interface_bulk(self):
+
+        data = [
+            {
+                'device': self.device.pk,
+                'name': 'Test Interface 4',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Interface 5',
+            },
+            {
+                'device': self.device.pk,
+                'name': 'Test Interface 6',
+            },
+        ]
+
+        url = reverse('dcim-api:interface-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Interface.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_interface(self):
 
         lag_interface = Interface.objects.create(
@@ -1823,6 +2428,32 @@ class DeviceBayTest(HttpStatusMixin, APITestCase):
         self.assertEqual(devicebay4.name, data['name'])
         self.assertEqual(devicebay4.installed_device_id, data['installed_device'])
 
+    def test_create_devicebay_bulk(self):
+
+        data = [
+            {
+                'device': self.parent_device.pk,
+                'name': 'Test Device Bay 4',
+            },
+            {
+                'device': self.parent_device.pk,
+                'name': 'Test Device Bay 5',
+            },
+            {
+                'device': self.parent_device.pk,
+                'name': 'Test Device Bay 6',
+            },
+        ]
+
+        url = reverse('dcim-api:devicebay-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(DeviceBay.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_devicebay(self):
 
         data = {
@@ -1906,6 +2537,38 @@ class InventoryItemTest(HttpStatusMixin, APITestCase):
         self.assertEqual(inventoryitem4.name, data['name'])
         self.assertEqual(inventoryitem4.manufacturer_id, data['manufacturer'])
 
+    def test_create_inventoryitem_bulk(self):
+
+        data = [
+            {
+                'device': self.device.pk,
+                'parent': self.inventoryitem1.pk,
+                'name': 'Test Inventory Item 4',
+                'manufacturer': self.manufacturer.pk,
+            },
+            {
+                'device': self.device.pk,
+                'parent': self.inventoryitem1.pk,
+                'name': 'Test Inventory Item 5',
+                'manufacturer': self.manufacturer.pk,
+            },
+            {
+                'device': self.device.pk,
+                'parent': self.inventoryitem1.pk,
+                'name': 'Test Inventory Item 6',
+                'manufacturer': self.manufacturer.pk,
+            },
+        ]
+
+        url = reverse('dcim-api:inventoryitem-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(InventoryItem.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_inventoryitem(self):
 
         data = {
@@ -2048,6 +2711,10 @@ class InterfaceConnectionTest(HttpStatusMixin, APITestCase):
         self.interface6 = Interface.objects.create(device=self.device, name='Test Interface 6')
         self.interface7 = Interface.objects.create(device=self.device, name='Test Interface 7')
         self.interface8 = Interface.objects.create(device=self.device, name='Test Interface 8')
+        self.interface9 = Interface.objects.create(device=self.device, name='Test Interface 9')
+        self.interface10 = Interface.objects.create(device=self.device, name='Test Interface 10')
+        self.interface11 = Interface.objects.create(device=self.device, name='Test Interface 11')
+        self.interface12 = Interface.objects.create(device=self.device, name='Test Interface 12')
         self.interfaceconnection1 = InterfaceConnection.objects.create(
             interface_a=self.interface1, interface_b=self.interface2
         )
@@ -2089,6 +2756,32 @@ class InterfaceConnectionTest(HttpStatusMixin, APITestCase):
         self.assertEqual(interfaceconnection4.interface_a_id, data['interface_a'])
         self.assertEqual(interfaceconnection4.interface_b_id, data['interface_b'])
 
+    def test_create_interfaceconnection_bulk(self):
+
+        data = [
+            {
+                'interface_a': self.interface7.pk,
+                'interface_b': self.interface8.pk,
+            },
+            {
+                'interface_a': self.interface9.pk,
+                'interface_b': self.interface10.pk,
+            },
+            {
+                'interface_a': self.interface11.pk,
+                'interface_b': self.interface12.pk,
+            },
+        ]
+
+        url = reverse('dcim-api:interfaceconnection-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(InterfaceConnection.objects.count(), 6)
+        self.assertEqual(response.data[0]['interface_a'], data[0]['interface_a'])
+        self.assertEqual(response.data[1]['interface_a'], data[1]['interface_a'])
+        self.assertEqual(response.data[2]['interface_a'], data[2]['interface_a'])
+
     def test_update_interfaceconnection(self):
 
         new_connection_status = not self.interfaceconnection1.connection_status
@@ -2170,6 +2863,7 @@ class VirtualChassisTest(HttpStatusMixin, APITestCase):
 
         self.vc1 = VirtualChassis.objects.create(domain='test-domain-1')
         self.vc2 = VirtualChassis.objects.create(domain='test-domain-2')
+        self.vc3 = VirtualChassis.objects.create(domain='test-domain-3')
 
     def test_get_virtualchassis(self):
 
@@ -2183,19 +2877,42 @@ class VirtualChassisTest(HttpStatusMixin, APITestCase):
         url = reverse('dcim-api:virtualchassis-list')
         response = self.client.get(url, **self.header)
 
-        self.assertEqual(response.data['count'], 2)
+        self.assertEqual(response.data['count'], 3)
 
     def test_create_virtualchassis(self):
 
         data = {
-            'domain': 'test-domain-3',
+            'domain': 'test-domain-4',
         }
 
         url = reverse('dcim-api:virtualchassis-list')
         response = self.client.post(url, data, format='json', **self.header)
         self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        vc3 = VirtualChassis.objects.get(pk=response.data['id'])
-        self.assertEqual(vc3.domain, data['domain'])
+        self.assertEqual(VirtualChassis.objects.count(), 4)
+        vc4 = VirtualChassis.objects.get(pk=response.data['id'])
+        self.assertEqual(vc4.domain, data['domain'])
+
+    def test_create_virtualchassis_bulk(self):
+
+        data = [
+            {
+                'domain': 'test-domain-4',
+            },
+            {
+                'domain': 'test-domain-5',
+            },
+            {
+                'domain': 'test-domain-6',
+            },
+        ]
+
+        url = reverse('dcim-api:virtualchassis-list')
+        response = self.client.post(url, data, format='json', **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(VirtualChassis.objects.count(), 6)
+        self.assertEqual(response.data[0]['domain'], data[0]['domain'])
+        self.assertEqual(response.data[1]['domain'], data[1]['domain'])
+        self.assertEqual(response.data[2]['domain'], data[2]['domain'])
 
     def test_update_virtualchassis(self):
 
@@ -2207,7 +2924,7 @@ class VirtualChassisTest(HttpStatusMixin, APITestCase):
         response = self.client.put(url, data, format='json', **self.header)
 
         self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(VirtualChassis.objects.count(), 2)
+        self.assertEqual(VirtualChassis.objects.count(), 3)
         vc1 = VirtualChassis.objects.get(pk=response.data['id'])
         self.assertEqual(vc1.domain, data['domain'])
 
@@ -2217,7 +2934,7 @@ class VirtualChassisTest(HttpStatusMixin, APITestCase):
         response = self.client.delete(url, **self.header)
 
         self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(VirtualChassis.objects.count(), 1)
+        self.assertEqual(VirtualChassis.objects.count(), 2)
 
 
 class VCMembershipTest(HttpStatusMixin, APITestCase):
@@ -2378,6 +3095,43 @@ class VCMembershipTest(HttpStatusMixin, APITestCase):
 
         self.assertEqual(VCMembership.objects.count(), 9)
 
+    def test_create_vcmembership_bulk(self):
+
+        vc = VirtualChassis.objects.create()
+
+        data = [
+            {
+                'virtual_chassis': vc.pk,
+                'device': self.device7.pk,
+                'position': 1,
+                'is_master': True,
+                'priority': 10,
+            },
+            {
+                'virtual_chassis': vc.pk,
+                'device': self.device8.pk,
+                'position': 2,
+                'is_master': False,
+                'priority': 20,
+            },
+            {
+                'virtual_chassis': vc.pk,
+                'device': self.device9.pk,
+                'position': 3,
+                'is_master': False,
+                'priority': 30,
+            },
+        ]
+
+        url = reverse('dcim-api:vcmembership-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(VCMembership.objects.count(), 9)
+        self.assertEqual(response.data[0]['device'], data[0]['device'])
+        self.assertEqual(response.data[1]['device'], data[1]['device'])
+        self.assertEqual(response.data[2]['device'], data[2]['device'])
+
     def test_update_vcmembership(self):
 
         data = {
diff --git a/netbox/extras/tests/test_api.py b/netbox/extras/tests/test_api.py
index 46e0b3bda..036d8143c 100644
--- a/netbox/extras/tests/test_api.py
+++ b/netbox/extras/tests/test_api.py
@@ -63,6 +63,35 @@ class GraphTest(HttpStatusMixin, APITestCase):
         self.assertEqual(graph4.name, data['name'])
         self.assertEqual(graph4.source, data['source'])
 
+    def test_create_graph_bulk(self):
+
+        data = [
+            {
+                'type': GRAPH_TYPE_SITE,
+                'name': 'Test Graph 4',
+                'source': 'http://example.com/graphs.py?site={{ obj.name }}&foo=4',
+            },
+            {
+                'type': GRAPH_TYPE_SITE,
+                'name': 'Test Graph 5',
+                'source': 'http://example.com/graphs.py?site={{ obj.name }}&foo=5',
+            },
+            {
+                'type': GRAPH_TYPE_SITE,
+                'name': 'Test Graph 6',
+                'source': 'http://example.com/graphs.py?site={{ obj.name }}&foo=6',
+            },
+        ]
+
+        url = reverse('extras-api:graph-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Graph.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_graph(self):
 
         data = {
@@ -144,6 +173,35 @@ class ExportTemplateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(exporttemplate4.name, data['name'])
         self.assertEqual(exporttemplate4.template_code, data['template_code'])
 
+    def test_create_exporttemplate_bulk(self):
+
+        data = [
+            {
+                'content_type': self.content_type.pk,
+                'name': 'Test Export Template 4',
+                'template_code': '{% for obj in queryset %}{{ obj.name }}\n{% endfor %}',
+            },
+            {
+                'content_type': self.content_type.pk,
+                'name': 'Test Export Template 5',
+                'template_code': '{% for obj in queryset %}{{ obj.name }}\n{% endfor %}',
+            },
+            {
+                'content_type': self.content_type.pk,
+                'name': 'Test Export Template 6',
+                'template_code': '{% for obj in queryset %}{{ obj.name }}\n{% endfor %}',
+            },
+        ]
+
+        url = reverse('extras-api:exporttemplate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(ExportTemplate.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_exporttemplate(self):
 
         data = {
diff --git a/netbox/ipam/tests/test_api.py b/netbox/ipam/tests/test_api.py
index 0f07e34ce..505d914a0 100644
--- a/netbox/ipam/tests/test_api.py
+++ b/netbox/ipam/tests/test_api.py
@@ -55,6 +55,32 @@ class VRFTest(HttpStatusMixin, APITestCase):
         self.assertEqual(vrf4.name, data['name'])
         self.assertEqual(vrf4.rd, data['rd'])
 
+    def test_create_vrf_bulk(self):
+
+        data = [
+            {
+                'name': 'Test VRF 4',
+                'rd': '65000:4',
+            },
+            {
+                'name': 'Test VRF 5',
+                'rd': '65000:5',
+            },
+            {
+                'name': 'Test VRF 6',
+                'rd': '65000:6',
+            },
+        ]
+
+        url = reverse('ipam-api:vrf-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(VRF.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_vrf(self):
 
         data = {
@@ -122,6 +148,32 @@ class RIRTest(HttpStatusMixin, APITestCase):
         self.assertEqual(rir4.name, data['name'])
         self.assertEqual(rir4.slug, data['slug'])
 
+    def test_create_rir_bulk(self):
+
+        data = [
+            {
+                'name': 'Test RIR 4',
+                'slug': 'test-rir-4',
+            },
+            {
+                'name': 'Test RIR 5',
+                'slug': 'test-rir-5',
+            },
+            {
+                'name': 'Test RIR 6',
+                'slug': 'test-rir-6',
+            },
+        ]
+
+        url = reverse('ipam-api:rir-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(RIR.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_rir(self):
 
         data = {
@@ -191,6 +243,32 @@ class AggregateTest(HttpStatusMixin, APITestCase):
         self.assertEqual(str(aggregate4.prefix), data['prefix'])
         self.assertEqual(aggregate4.rir_id, data['rir'])
 
+    def test_create_aggregate_bulk(self):
+
+        data = [
+            {
+                'prefix': '100.0.0.0/8',
+                'rir': self.rir1.pk,
+            },
+            {
+                'prefix': '101.0.0.0/8',
+                'rir': self.rir1.pk,
+            },
+            {
+                'prefix': '102.0.0.0/8',
+                'rir': self.rir1.pk,
+            },
+        ]
+
+        url = reverse('ipam-api:aggregate-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Aggregate.objects.count(), 6)
+        self.assertEqual(response.data[0]['prefix'], data[0]['prefix'])
+        self.assertEqual(response.data[1]['prefix'], data[1]['prefix'])
+        self.assertEqual(response.data[2]['prefix'], data[2]['prefix'])
+
     def test_update_aggregate(self):
 
         data = {
@@ -258,6 +336,32 @@ class RoleTest(HttpStatusMixin, APITestCase):
         self.assertEqual(role4.name, data['name'])
         self.assertEqual(role4.slug, data['slug'])
 
+    def test_create_role_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Role 4',
+                'slug': 'test-role-4',
+            },
+            {
+                'name': 'Test Role 5',
+                'slug': 'test-role-5',
+            },
+            {
+                'name': 'Test Role 6',
+                'slug': 'test-role-6',
+            },
+        ]
+
+        url = reverse('ipam-api:role-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Role.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_role(self):
 
         data = {
@@ -335,6 +439,29 @@ class PrefixTest(HttpStatusMixin, APITestCase):
         self.assertEqual(prefix4.vlan_id, data['vlan'])
         self.assertEqual(prefix4.role_id, data['role'])
 
+    def test_create_prefix_bulk(self):
+
+        data = [
+            {
+                'prefix': '10.0.1.0/24',
+            },
+            {
+                'prefix': '10.0.2.0/24',
+            },
+            {
+                'prefix': '10.0.3.0/24',
+            },
+        ]
+
+        url = reverse('ipam-api:prefix-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Prefix.objects.count(), 6)
+        self.assertEqual(response.data[0]['prefix'], data[0]['prefix'])
+        self.assertEqual(response.data[1]['prefix'], data[1]['prefix'])
+        self.assertEqual(response.data[2]['prefix'], data[2]['prefix'])
+
     def test_update_prefix(self):
 
         data = {
@@ -530,6 +657,29 @@ class IPAddressTest(HttpStatusMixin, APITestCase):
         self.assertEqual(str(ipaddress4.address), data['address'])
         self.assertEqual(ipaddress4.vrf_id, data['vrf'])
 
+    def test_create_ipaddress_bulk(self):
+
+        data = [
+            {
+                'address': '192.168.0.4/24',
+            },
+            {
+                'address': '192.168.0.5/24',
+            },
+            {
+                'address': '192.168.0.6/24',
+            },
+        ]
+
+        url = reverse('ipam-api:ipaddress-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(IPAddress.objects.count(), 6)
+        self.assertEqual(response.data[0]['address'], data[0]['address'])
+        self.assertEqual(response.data[1]['address'], data[1]['address'])
+        self.assertEqual(response.data[2]['address'], data[2]['address'])
+
     def test_update_ipaddress(self):
 
         data = {
@@ -597,6 +747,32 @@ class VLANGroupTest(HttpStatusMixin, APITestCase):
         self.assertEqual(vlangroup4.name, data['name'])
         self.assertEqual(vlangroup4.slug, data['slug'])
 
+    def test_create_vlangroup_bulk(self):
+
+        data = [
+            {
+                'name': 'Test VLAN Group 4',
+                'slug': 'test-vlan-group-4',
+            },
+            {
+                'name': 'Test VLAN Group 5',
+                'slug': 'test-vlan-group-5',
+            },
+            {
+                'name': 'Test VLAN Group 6',
+                'slug': 'test-vlan-group-6',
+            },
+        ]
+
+        url = reverse('ipam-api:vlangroup-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(VLANGroup.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_vlangroup(self):
 
         data = {
@@ -664,6 +840,32 @@ class VLANTest(HttpStatusMixin, APITestCase):
         self.assertEqual(vlan4.vid, data['vid'])
         self.assertEqual(vlan4.name, data['name'])
 
+    def test_create_vlan_bulk(self):
+
+        data = [
+            {
+                'vid': 4,
+                'name': 'Test VLAN 4',
+            },
+            {
+                'vid': 5,
+                'name': 'Test VLAN 5',
+            },
+            {
+                'vid': 6,
+                'name': 'Test VLAN 6',
+            },
+        ]
+
+        url = reverse('ipam-api:vlan-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(VLAN.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_vlan(self):
 
         data = {
@@ -751,6 +953,38 @@ class ServiceTest(HttpStatusMixin, APITestCase):
         self.assertEqual(service4.protocol, data['protocol'])
         self.assertEqual(service4.port, data['port'])
 
+    def test_create_service_bulk(self):
+
+        data = [
+            {
+                'device': self.device1.pk,
+                'name': 'Test Service 4',
+                'protocol': IP_PROTOCOL_TCP,
+                'port': 4,
+            },
+            {
+                'device': self.device1.pk,
+                'name': 'Test Service 5',
+                'protocol': IP_PROTOCOL_TCP,
+                'port': 5,
+            },
+            {
+                'device': self.device1.pk,
+                'name': 'Test Service 6',
+                'protocol': IP_PROTOCOL_TCP,
+                'port': 6,
+            },
+        ]
+
+        url = reverse('ipam-api:service-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Service.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_service(self):
 
         data = {
diff --git a/netbox/secrets/tests/test_api.py b/netbox/secrets/tests/test_api.py
index 3a51959c1..52cb289c5 100644
--- a/netbox/secrets/tests/test_api.py
+++ b/netbox/secrets/tests/test_api.py
@@ -81,8 +81,8 @@ class SecretRoleTest(HttpStatusMixin, APITestCase):
     def test_create_secretrole(self):
 
         data = {
-            'name': 'Test SecretRole 4',
-            'slug': 'test-secretrole-4',
+            'name': 'Test Secret Role 4',
+            'slug': 'test-secret-role-4',
         }
 
         url = reverse('secrets-api:secretrole-list')
@@ -94,6 +94,32 @@ class SecretRoleTest(HttpStatusMixin, APITestCase):
         self.assertEqual(secretrole4.name, data['name'])
         self.assertEqual(secretrole4.slug, data['slug'])
 
+    def test_create_secretrole_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Secret Role 4',
+                'slug': 'test-secret-role-4',
+            },
+            {
+                'name': 'Test Secret Role 5',
+                'slug': 'test-secret-role-5',
+            },
+            {
+                'name': 'Test Secret Role 6',
+                'slug': 'test-secret-role-6',
+            },
+        ]
+
+        url = reverse('secrets-api:secretrole-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(SecretRole.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_secretrole(self):
 
         data = {
@@ -201,6 +227,35 @@ class SecretTest(HttpStatusMixin, APITestCase):
         self.assertEqual(secret4.role_id, data['role'])
         self.assertEqual(secret4.plaintext, data['plaintext'])
 
+    def test_create_secret_bulk(self):
+
+        data = [
+            {
+                'device': self.device.pk,
+                'role': self.secretrole1.pk,
+                'plaintext': 'Secret #4 Plaintext',
+            },
+            {
+                'device': self.device.pk,
+                'role': self.secretrole1.pk,
+                'plaintext': 'Secret #5 Plaintext',
+            },
+            {
+                'device': self.device.pk,
+                'role': self.secretrole1.pk,
+                'plaintext': 'Secret #6 Plaintext',
+            },
+        ]
+
+        url = reverse('secrets-api:secret-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Secret.objects.count(), 6)
+        self.assertEqual(response.data[0]['plaintext'], data[0]['plaintext'])
+        self.assertEqual(response.data[1]['plaintext'], data[1]['plaintext'])
+        self.assertEqual(response.data[2]['plaintext'], data[2]['plaintext'])
+
     def test_update_secret(self):
 
         data = {
diff --git a/netbox/tenancy/tests/test_api.py b/netbox/tenancy/tests/test_api.py
index 2930d464a..f1238eddb 100644
--- a/netbox/tenancy/tests/test_api.py
+++ b/netbox/tenancy/tests/test_api.py
@@ -52,6 +52,32 @@ class TenantGroupTest(HttpStatusMixin, APITestCase):
         self.assertEqual(tenantgroup4.name, data['name'])
         self.assertEqual(tenantgroup4.slug, data['slug'])
 
+    def test_create_tenantgroup_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Tenant Group 4',
+                'slug': 'test-tenant-group-4',
+            },
+            {
+                'name': 'Test Tenant Group 5',
+                'slug': 'test-tenant-group-5',
+            },
+            {
+                'name': 'Test Tenant Group 6',
+                'slug': 'test-tenant-group-6',
+            },
+        ]
+
+        url = reverse('tenancy-api:tenantgroup-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(TenantGroup.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_tenantgroup(self):
 
         data = {
@@ -123,6 +149,32 @@ class TenantTest(HttpStatusMixin, APITestCase):
         self.assertEqual(tenant4.slug, data['slug'])
         self.assertEqual(tenant4.group_id, data['group'])
 
+    def test_create_tenant_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Tenant 4',
+                'slug': 'test-tenant-4',
+            },
+            {
+                'name': 'Test Tenant 5',
+                'slug': 'test-tenant-5',
+            },
+            {
+                'name': 'Test Tenant 6',
+                'slug': 'test-tenant-6',
+            },
+        ]
+
+        url = reverse('tenancy-api:tenant-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Tenant.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_tenant(self):
 
         data = {
diff --git a/netbox/virtualization/tests/test_api.py b/netbox/virtualization/tests/test_api.py
index ee06ba31b..1f9e72ee5 100644
--- a/netbox/virtualization/tests/test_api.py
+++ b/netbox/virtualization/tests/test_api.py
@@ -52,6 +52,32 @@ class ClusterTypeTest(HttpStatusMixin, APITestCase):
         self.assertEqual(clustertype4.name, data['name'])
         self.assertEqual(clustertype4.slug, data['slug'])
 
+    def test_create_clustertype_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Cluster Type 4',
+                'slug': 'test-cluster-type-4',
+            },
+            {
+                'name': 'Test Cluster Type 5',
+                'slug': 'test-cluster-type-5',
+            },
+            {
+                'name': 'Test Cluster Type 6',
+                'slug': 'test-cluster-type-6',
+            },
+        ]
+
+        url = reverse('virtualization-api:clustertype-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(ClusterType.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_clustertype(self):
 
         data = {
@@ -119,6 +145,32 @@ class ClusterGroupTest(HttpStatusMixin, APITestCase):
         self.assertEqual(clustergroup4.name, data['name'])
         self.assertEqual(clustergroup4.slug, data['slug'])
 
+    def test_create_clustergroup_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Cluster Group 4',
+                'slug': 'test-cluster-group-4',
+            },
+            {
+                'name': 'Test Cluster Group 5',
+                'slug': 'test-cluster-group-5',
+            },
+            {
+                'name': 'Test Cluster Group 6',
+                'slug': 'test-cluster-group-6',
+            },
+        ]
+
+        url = reverse('virtualization-api:clustergroup-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(ClusterGroup.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_clustergroup(self):
 
         data = {
@@ -191,6 +243,35 @@ class ClusterTest(HttpStatusMixin, APITestCase):
         self.assertEqual(cluster4.type.pk, data['type'])
         self.assertEqual(cluster4.group.pk, data['group'])
 
+    def test_create_cluster_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Cluster 4',
+                'type': ClusterType.objects.first().pk,
+                'group': ClusterGroup.objects.first().pk,
+            },
+            {
+                'name': 'Test Cluster 5',
+                'type': ClusterType.objects.first().pk,
+                'group': ClusterGroup.objects.first().pk,
+            },
+            {
+                'name': 'Test Cluster 6',
+                'type': ClusterType.objects.first().pk,
+                'group': ClusterGroup.objects.first().pk,
+            },
+        ]
+
+        url = reverse('virtualization-api:cluster-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(Cluster.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_cluster(self):
 
         cluster_type2 = ClusterType.objects.create(name='Test Cluster Type 2', slug='test-cluster-type-2')
@@ -230,11 +311,11 @@ class VirtualMachineTest(HttpStatusMixin, APITestCase):
 
         cluster_type = ClusterType.objects.create(name='Test Cluster Type 1', slug='test-cluster-type-1')
         cluster_group = ClusterGroup.objects.create(name='Test Cluster Group 1', slug='test-cluster-group-1')
-        cluster = Cluster.objects.create(name='Test Cluster 1', type=cluster_type, group=cluster_group)
+        self.cluster1 = Cluster.objects.create(name='Test Cluster 1', type=cluster_type, group=cluster_group)
 
-        self.virtualmachine1 = VirtualMachine.objects.create(name='Test Virtual Machine 1', cluster=cluster)
-        self.virtualmachine2 = VirtualMachine.objects.create(name='Test Virtual Machine 2', cluster=cluster)
-        self.virtualmachine3 = VirtualMachine.objects.create(name='Test Virtual Machine 3', cluster=cluster)
+        self.virtualmachine1 = VirtualMachine.objects.create(name='Test Virtual Machine 1', cluster=self.cluster1)
+        self.virtualmachine2 = VirtualMachine.objects.create(name='Test Virtual Machine 2', cluster=self.cluster1)
+        self.virtualmachine3 = VirtualMachine.objects.create(name='Test Virtual Machine 3', cluster=self.cluster1)
 
     def test_get_virtualmachine(self):
 
@@ -254,7 +335,7 @@ class VirtualMachineTest(HttpStatusMixin, APITestCase):
 
         data = {
             'name': 'Test Virtual Machine 4',
-            'cluster': Cluster.objects.first().pk,
+            'cluster': self.cluster1.pk,
         }
 
         url = reverse('virtualization-api:virtualmachine-list')
@@ -266,6 +347,32 @@ class VirtualMachineTest(HttpStatusMixin, APITestCase):
         self.assertEqual(virtualmachine4.name, data['name'])
         self.assertEqual(virtualmachine4.cluster.pk, data['cluster'])
 
+    def test_create_virtualmachine_bulk(self):
+
+        data = [
+            {
+                'name': 'Test Virtual Machine 4',
+                'cluster': self.cluster1.pk,
+            },
+            {
+                'name': 'Test Virtual Machine 5',
+                'cluster': self.cluster1.pk,
+            },
+            {
+                'name': 'Test Virtual Machine 6',
+                'cluster': self.cluster1.pk,
+            },
+        ]
+
+        url = reverse('virtualization-api:virtualmachine-list')
+        response = self.client.post(url, data, format='json', **self.header)
+
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+        self.assertEqual(VirtualMachine.objects.count(), 6)
+        self.assertEqual(response.data[0]['name'], data[0]['name'])
+        self.assertEqual(response.data[1]['name'], data[1]['name'])
+        self.assertEqual(response.data[2]['name'], data[2]['name'])
+
     def test_update_virtualmachine(self):
 
         cluster2 = Cluster.objects.create(