diff --git a/src/services/privateDns/data.ts b/src/services/privateDns/data.ts
index 01fc5716..2083beba 100644
--- a/src/services/privateDns/data.ts
+++ b/src/services/privateDns/data.ts
@@ -16,9 +16,87 @@ export interface RawAzurePrivateDnsZone
   extends Omit<PrivateZone, 'tags' | 'location'> {
   region: string
   resourceGroupId: string
+  records: RawAzurePrivateDnsMetadata[]
+  virtualNetworkLinks: RawAzurePrivateDnsMetadata[]
   Tags: TagMap
 }
 
+export interface RawAzurePrivateDnsMetadata {
+  id: string
+  name: string
+  type: string
+}
+
+export const listVirtualNetworkLinks = async (
+  client: PrivateDnsManagementClient,
+  resourceGroup: string,
+  privateZoneName: string
+): Promise<RawAzurePrivateDnsMetadata[]> => {
+  const vnetworkLinks: RawAzurePrivateDnsMetadata[] = []
+  const vnetworkLinksIterable = client.virtualNetworkLinks.list(
+    resourceGroup,
+    privateZoneName
+  )
+  await tryCatchWrapper(
+    async () => {
+      for await (const vnetworkLink of vnetworkLinksIterable) {
+        if (vnetworkLink) {
+          const { id, name, type } = vnetworkLink
+          const recordType = type?.split('/').pop()
+          vnetworkLinks.push({
+            id,
+            name,
+            type: recordType,
+          } as RawAzurePrivateDnsMetadata)
+        }
+
+      }
+    }
+    , {
+      service: 'Virtual Network Links',
+      client,
+      scope: 'virtualNetworkLinks',
+      operation: 'listVirtualNetworkLinks',
+    }
+  )
+  return vnetworkLinks
+}
+
+export const listRecordSets = async (
+  client: PrivateDnsManagementClient,
+  resourceGroup: string,
+  privateZoneName: string
+): Promise<RawAzurePrivateDnsMetadata[]> => {
+  const records: RawAzurePrivateDnsMetadata[] = []
+  const recordsIterable = client.recordSets.list(
+    resourceGroup,
+    privateZoneName
+  )
+  await tryCatchWrapper(
+    async () => {
+      for await (const record of recordsIterable) {
+        if (record) {
+          const { id, name, type } = record
+          const recordType = type?.split('/').pop()
+          records.push({
+            id,
+            name,
+            type: recordType,
+          } as RawAzurePrivateDnsMetadata)
+        }
+
+      }
+    }
+    , {
+      service: 'Records Sets',
+      client,
+      scope: 'recordSets',
+      operation: 'listRecordSets',
+    }
+  )
+  return records
+}
+
 export default async ({
   regions,
   config,
@@ -35,6 +113,7 @@ export default async ({
     const privateDnsZones: RawAzurePrivateDnsZone[] = []
     const privateDnsZoneIterable: PagedAsyncIterableIterator<PrivateZone> =
       client.privateZones.list()
+    client.virtualNetworkLinks
     await tryCatchWrapper(
       async () => {
         for await (const privateDnsZone of privateDnsZoneIterable) {
@@ -46,6 +125,8 @@ export default async ({
               ...rest,
               region,
               resourceGroupId,
+              virtualNetworkLinks: await listVirtualNetworkLinks(client, resourceGroupId, privateDnsZone.name),
+              records: await listRecordSets(client, resourceGroupId, privateDnsZone.name),
               Tags: tags || {},
             })
           }
diff --git a/src/services/privateDns/format.ts b/src/services/privateDns/format.ts
index a2b2dee3..6afeb6fe 100644
--- a/src/services/privateDns/format.ts
+++ b/src/services/privateDns/format.ts
@@ -25,8 +25,21 @@ export default ({
     numberOfVirtualNetworkLinksWithRegistration,
     provisioningState,
     internalId,
-    resourceGroupId
+    resourceGroupId,
+    records = [],
+    virtualNetworkLinks = []
   } = service
+
+  // Records
+  const aRecords = records.filter(r => r.type === 'A').map(r => r.id)
+  const aaaaRecords = records.filter(r => r.type === 'AAAA').map(r => r.id)
+  const mxRecords = records.filter(r => r.type === 'MX').map(r => r.id)
+  const ptrRecords = records.filter(r => r.type === 'PTR').map(r => r.id)
+  const soaRecord = records.filter(r => r.type === 'SOA').map(r => r.id)
+  const srvRecords = records.filter(r => r.type === 'SRV').map(r => r.id)
+  const txtRecords = records.filter(r => r.type === 'TXT').map(r => r.id)
+  const cnameRecord = records.filter(r => r.type === 'CNAME').pop()?.id
+
   return {
     id,
     subscriptionId: account,
@@ -43,6 +56,15 @@ export default ({
     provisioningState,
     internalId,
     tags: formatTagsFromMap(Tags),
-    resourceGroupId
+    resourceGroupId,
+    aRecords,
+    aaaaRecords,
+    mxRecords,
+    ptrRecords,
+    soaRecord,
+    srvRecords,
+    txtRecords,
+    cnameRecord,
+    virtualNetworkLinks: virtualNetworkLinks.map(r => r.id)
   }
 }
diff --git a/src/services/privateDns/schema.graphql b/src/services/privateDns/schema.graphql
index 0751ccbb..c822fd61 100644
--- a/src/services/privateDns/schema.graphql
+++ b/src/services/privateDns/schema.graphql
@@ -13,5 +13,14 @@ type azurePrivateDnsZone implements azureResource
   numberOfVirtualNetworkLinksWithRegistration: Int @search
   provisioningState: String @search(by: [hash, regexp])
   internalId: String @search(by: [hash, regexp])
+  aRecords: [String] @search(by: [hash])
+  aaaaRecords: [String] @search(by: [hash])
+  cnameRecord: String @search(by: [hash])
+  mxRecords: [String] @search(by: [hash])
+  ptrRecords: [String] @search(by: [hash])
+  soaRecord: [String] @search(by: [hash])
+  srvRecords: [String] @search(by: [hash])
+  txtRecords: [String] @search(by: [hash])
+  virtualNetworkLinks: [String] @search(by: [hash])
   resourceGroup: [azureResourceGroup] @hasInverse(field: privateDns)
 }
diff --git a/src/types/generated.ts b/src/types/generated.ts
index 25ac1891..30697fa3 100644
--- a/src/types/generated.ts
+++ b/src/types/generated.ts
@@ -4380,16 +4380,25 @@ export type AzurePostgreSqlServerVirtualNetworkRule = {
 };
 
 export type AzurePrivateDnsZone = AzureResource & {
+  aRecords?: Maybe<Array<Maybe<Scalars['String']>>>;
+  aaaaRecords?: Maybe<Array<Maybe<Scalars['String']>>>;
+  cnameRecord?: Maybe<Scalars['String']>;
   etag?: Maybe<Scalars['String']>;
   internalId?: Maybe<Scalars['String']>;
   maxNumberOfRecordSets?: Maybe<Scalars['Int']>;
   maxNumberOfVirtualNetworkLinks?: Maybe<Scalars['Int']>;
   maxNumberOfVirtualNetworkLinksWithRegistration?: Maybe<Scalars['Int']>;
+  mxRecords?: Maybe<Array<Maybe<Scalars['String']>>>;
   numberOfRecordSets?: Maybe<Scalars['Int']>;
   numberOfVirtualNetworkLinks?: Maybe<Scalars['Int']>;
   numberOfVirtualNetworkLinksWithRegistration?: Maybe<Scalars['Int']>;
   provisioningState?: Maybe<Scalars['String']>;
+  ptrRecords?: Maybe<Array<Maybe<Scalars['String']>>>;
   resourceGroup?: Maybe<Array<Maybe<AzureResourceGroup>>>;
+  soaRecord?: Maybe<Array<Maybe<Scalars['String']>>>;
+  srvRecords?: Maybe<Array<Maybe<Scalars['String']>>>;
+  txtRecords?: Maybe<Array<Maybe<Scalars['String']>>>;
+  virtualNetworkLinks?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
 export type AzurePublicIp = AzureResource & {