How To Get Parent GUID Of An Item In SharePoint Online Using REST API And Microsoft Graph

Jul 12, 2025 by Jeany 90 views

How to Retrieve the Parent GUID of a SharePoint Online List Item Using REST API and Microsoft Graph

In SharePoint Online, you often encounter scenarios where list items are structured in a hierarchical manner, resembling a tree-like structure. This structure is useful for organizing and managing content effectively. A common requirement in such scenarios is to retrieve the parent GUID (Globally Unique Identifier) of an item. This article explores how to obtain the parent GUID of a SharePoint Online list item using both the REST API and Microsoft Graph, providing a comprehensive guide for developers and SharePoint administrators.

Understanding the Importance of Parent GUIDs

Before diving into the technical details, it's crucial to understand why retrieving the parent GUID is essential. In a hierarchical structure, each item may have a parent, creating a relationship between them. The GUID, a unique identifier, allows you to programmatically navigate and manipulate this structure. For instance, you might need the parent GUID to:

Navigate the hierarchy: Traverse the tree structure to find related items.
Enforce permissions: Apply specific permissions based on the parent item.
Implement custom navigation: Build custom navigation components that reflect the hierarchical structure.
Perform bulk operations: Execute actions on items based on their parent.

Knowing how to retrieve the parent GUID is, therefore, a fundamental skill for anyone working with SharePoint Online and complex list structures.

Prerequisites

Before you start, ensure you have the following prerequisites in place:

SharePoint Online Environment: Access to a SharePoint Online site with the necessary permissions.
List with Items: A SharePoint list containing items structured in a tree-like hierarchy.
Development Environment: A suitable environment for running code (e.g., Visual Studio Code, PowerShell).
Authentication: Knowledge of how to authenticate with SharePoint Online using either REST API or Microsoft Graph.

Method 1: Using SharePoint REST API

The SharePoint REST API allows you to interact with SharePoint resources using standard HTTP requests. To retrieve the parent GUID of an item, you can use the following steps:

Step 1: Construct the REST API Endpoint

The first step is to construct the correct REST API endpoint. The endpoint should target the specific item for which you want to retrieve the parent GUID. The general format of the endpoint is:

_api/web/lists/GetByTitle('<list_title>')/items(<item_id>)/ParentFolder/UniqueId

Replace <list_title> with the actual title of your SharePoint list and <item_id> with the ID of the item. For example, if your list is named "MyList" and the item ID is 5, the endpoint would look like this:

_api/web/lists/GetByTitle('MyList')/items(5)/ParentFolder/UniqueId

This endpoint will return the UniqueId property of the parent folder, which is the parent GUID.

Step 2: Authenticate and Make the Request

Next, you need to authenticate with SharePoint Online and make the REST API request. You can use various authentication methods, such as the SharePoint Add-in model, OAuth, or Azure AD. Here’s an example using PowerShell:

# Replace with your SharePoint site URL and credentials
$SiteURL = "https://yourtenant.sharepoint.com/sites/yoursite"
$Username = "[email protected]"
$Password = "YourPassword"

# List Title and Item ID
$ListTitle = "MyList"
$ItemID = 5

# Construct the REST API endpoint
$apiUrl = "$SiteURL/_api/web/lists/GetByTitle('$ListTitle')/items($ItemID)/ParentFolder/UniqueId"

# Authenticate to SharePoint Online
$SecurePassword = ConvertTo-SecureString $Password -AsPlainText -Force
$Cred = New-Object PSCredential($Username, $SecurePassword)

# Create a new Client Context
$ctx = New-Object Microsoft.SharePoint.Client.ClientContext($SiteURL)
$ctx.Credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($Cred.UserName, $Cred.Password)

# Function to Invoke REST API
function Invoke-RestMethod {
    param (
        [string]$Url,
        [string]$Method = "GET",
        [string]$Body
    )

    try {
        $Headers = @{"Accept" = "application/json;odata=verbose"}
        if ($Body) {
            $Headers["Content-Type"] = "application/json;odata=verbose"
        }

        $Response = Invoke-WebRequest -Uri $Url -Method $Method -Headers $Headers -Body $Body -UseBasicParsing
        $JsonResponse = ConvertFrom-Json $Response.Content
        return $JsonResponse
    }
    catch {
        Write-Host "Error: $($_.Exception.Message)"
        return $null
    }
}

# Invoke the REST API to get the Parent GUID
$jsonResponse = Invoke-RestMethod -Url $apiUrl -Method "GET"

# Extract the Parent GUID
$parentGuid = $jsonResponse.d.UniqueId

# Output the Parent GUID
Write-Host "Parent GUID: $($parentGuid)"

This script authenticates to SharePoint Online, constructs the REST API endpoint, and retrieves the UniqueId of the parent folder.

Step 3: Parse the Response

The REST API response is typically in JSON format. You need to parse the JSON response to extract the parent GUID. In the example above, the parent GUID is extracted using $jsonResponse.d.UniqueId. The d property contains the actual results, and UniqueId is the property holding the parent GUID.

Example in JavaScript

Here’s an example using JavaScript and the SharePoint REST API:

function getParentGuid(siteUrl, listTitle, itemId, accessToken) {
    const apiUrl = `${siteUrl}/_api/web/lists/GetByTitle('${listTitle}')/items(${itemId})/ParentFolder/UniqueId`;

    return fetch(apiUrl, {
        method: 'GET',
        headers: {
            'Accept': 'application/json;odata=verbose',
            'Authorization': `Bearer ${accessToken}`
        }
    })
    .then(response => {
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        return response.json();
    })
    .then(data => {
        return data.d.UniqueId;
    })
    .catch(error => {
        console.error('Error:', error);
        return null;
    });
}

// Example usage:
const siteUrl = "https://yourtenant.sharepoint.com/sites/yoursite";
const listTitle = "MyList";
const itemId = 5;
const accessToken = "YOUR_ACCESS_TOKEN"; // Replace with your actual access token

getParentGuid(siteUrl, listTitle, itemId, accessToken)
    .then(parentGuid => {
        if (parentGuid) {
            console.log("Parent GUID:", parentGuid);
        } else {
            console.log("Failed to retrieve Parent GUID.");
        }
    });

This JavaScript code fetches the parent GUID using the REST API and logs it to the console. Ensure you replace YOUR_ACCESS_TOKEN with a valid access token for your SharePoint Online environment.

Method 2: Using Microsoft Graph

Microsoft Graph is a unified API endpoint for accessing data across Microsoft 365 services, including SharePoint Online. Using Microsoft Graph to retrieve the parent GUID offers a more modern and versatile approach.

Step 1: Construct the Microsoft Graph Endpoint

The Microsoft Graph endpoint for retrieving the parent GUID of a SharePoint list item is:

/sites/{site-id}/lists/{list-id}/items/{item-id}?$expand=fields($select=ParentReference)

Replace {site-id}, {list-id}, and {item-id} with the appropriate values. To get the site ID and list ID, you can use the following Graph API calls:

Get Site ID: /sites/{site-url}
Get List ID: /sites/{site-id}/lists?$filter=displayName eq '{list-title}'

Here’s an example endpoint:

/sites/contoso.sharepoint.com,f92f9e40-1111-4200-98b4-88883d184c15,79f22e81-2222-459d-8257-3814b19639aa/lists/e1c7e091-3333-400b-a353-9d53c9666bc7/items/5?$expand=fields($select=ParentReference)

This endpoint expands the fields property and selects the ParentReference field, which contains the parent GUID.

Step 2: Authenticate and Make the Request

To use Microsoft Graph, you need to authenticate with Azure Active Directory (Azure AD) and obtain an access token. Here’s an example using PowerShell:

# Replace with your Tenant ID, App ID, and App Secret
$TenantId = "your-tenant-id"
$AppId = "your-app-id"
$AppSecret = "your-app-secret"

# SharePoint Site URL, List Title, and Item ID
$SiteURL = "https://yourtenant.sharepoint.com/sites/yoursite"
$ListTitle = "MyList"
$ItemID = 5

# Function to get Access Token
function Get-AccessToken {
    param (
        [string]$TenantId,
        [string]$AppId,
        [string]$AppSecret
    )

    $resource = "https://graph.microsoft.com"
    $authUrl = "https://login.microsoftonline.com/$TenantId/oauth2/token"
    $body = @{
        grant_type = "client_credentials"
        resource   = $resource
        client_id  = $AppId
        client_secret = $AppSecret
    }

    try {
        $response = Invoke-RestMethod -Uri $authUrl -Method Post -Body $body
        return $response.access_token
    }
    catch {
        Write-Host "Error: $($_.Exception.Message)"
        return $null
    }
}

# Get Access Token
$accessToken = Get-AccessToken -TenantId $TenantId -AppId $AppId -AppSecret $AppSecret

if ($accessToken) {
    # Function to Invoke Graph API
    function Invoke-GraphApi {
        param (
            [string]$Url,
            [string]$AccessToken
        )

        try {
            $Headers = @{
                "Authorization" = "Bearer $($AccessToken)"
                "Content-Type" = "application/json"
            }

            $Response = Invoke-RestMethod -Uri $Url -Headers $Headers
            return $Response
        }
        catch {
            Write-Host "Error: $($_.Exception.Message)"
            return $null
        }
    }

    # Get Site ID
    $siteUrlEncoded = $SiteURL.Replace("https://", "")
    $siteIdUrl = "https://graph.microsoft.com/v1.0/sites/$siteUrlEncoded"
    $siteResponse = Invoke-GraphApi -Url $siteIdUrl -AccessToken $accessToken
    $siteId = $siteResponse.id

    # Get List ID
    $listUrl = "https://graph.microsoft.com/v1.0/sites/$siteId/lists?`$filter=displayName eq '$ListTitle'"
    $listResponse = Invoke-GraphApi -Url $listUrl -AccessToken $accessToken
    $listId = $listResponse.value[0].id

    # Construct the Graph API endpoint
    $apiUrl = "https://graph.microsoft.com/v1.0/sites/$siteId/lists/$listId/items/$ItemID?`$expand=fields(`$select=ParentReference)"

    # Invoke the Graph API to get the Parent GUID
    $jsonResponse = Invoke-GraphApi -Url $apiUrl -AccessToken $accessToken

    # Extract the Parent GUID
    $parentGuid = $jsonResponse.fields.ParentReference.id

    # Output the Parent GUID
    Write-Host "Parent GUID: $($parentGuid)"
}
else {
    Write-Host "Failed to retrieve access token."
}

This script retrieves an access token, gets the site and list IDs, constructs the Microsoft Graph endpoint, and retrieves the parent GUID.

Step 3: Parse the Response

The Microsoft Graph response is also in JSON format. The parent GUID is located in the fields.ParentReference.id property. In the example above, the parent GUID is extracted using $jsonResponse.fields.ParentReference.id.

Example in JavaScript

Here’s an example using JavaScript and Microsoft Graph:

async function getParentGuidGraph(siteId, listId, itemId, accessToken) {
    const apiUrl = `https://graph.microsoft.com/v1.0/sites/${siteId}/lists/${listId}/items/${itemId}?$expand=fields($select=ParentReference)`;

    try {
        const response = await fetch(apiUrl, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${accessToken}`,
                'Content-Type': 'application/json'
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }

        const data = await response.json();
        return data.fields.ParentReference.id;
    }
    catch (error) {
        console.error('Error:', error);
        return null;
    }
}

// Example usage:
const siteId = "your_site_id"; // Replace with your site ID
const listId = "your_list_id"; // Replace with your list ID
const itemId = 5;
const accessToken = "YOUR_ACCESS_TOKEN"; // Replace with your actual access token

getParentGuidGraph(siteId, listId, itemId, accessToken)
    .then(parentGuid => {
        if (parentGuid) {
            console.log("Parent GUID:", parentGuid);
        } else {
            console.log("Failed to retrieve Parent GUID.");
        }
    });

This JavaScript code fetches the parent GUID using Microsoft Graph and logs it to the console. Ensure you replace your_site_id, your_list_id, and YOUR_ACCESS_TOKEN with your actual values.

Comparing REST API and Microsoft Graph

Both REST API and Microsoft Graph can be used to retrieve the parent GUID of a SharePoint list item, but they have different strengths and weaknesses:

REST API
- Pros: Simpler for basic operations, well-documented for SharePoint-specific tasks.
- Cons: Requires more SharePoint-specific knowledge, less versatile for accessing other Microsoft 365 services.
Microsoft Graph
- Pros: Unified API for Microsoft 365, more versatile, follows modern standards.
- Cons: More complex setup, requires Azure AD authentication, might have a steeper learning curve.

Choosing between REST API and Microsoft Graph depends on your specific requirements and the scope of your project. For SharePoint-centric tasks, REST API might be sufficient, while Microsoft Graph is a better choice for broader Microsoft 365 integrations.

Best Practices and Considerations

When retrieving the parent GUID of a SharePoint list item, consider the following best practices:

Error Handling: Implement robust error handling to manage scenarios where the item or parent folder is not found.
Rate Limiting: Be mindful of SharePoint Online and Microsoft Graph rate limits to avoid throttling.
Authentication: Use secure authentication methods and manage access tokens properly.
Performance: Optimize your queries to minimize the number of requests and improve performance.
Permissions: Ensure your application has the necessary permissions to access SharePoint Online resources.

Conclusion

Retrieving the parent GUID of a SharePoint Online list item is a crucial task for managing hierarchical data structures. This article has provided a detailed guide on how to achieve this using both the SharePoint REST API and Microsoft Graph. By understanding the strengths and weaknesses of each method, you can choose the most appropriate approach for your specific needs. Whether you opt for the simplicity of REST API or the versatility of Microsoft Graph, the ability to programmatically access parent GUIDs will empower you to build more sophisticated and efficient SharePoint solutions. Always adhere to best practices and consider the specific requirements of your project to ensure optimal performance and security.