Is it possible to find the nodes connected to a node in python?

Question

Is it possible to find nodes connected to a node?

For example, could you trace your way back through a node tree from the material output node by finding the node connected to the material output node, then finding the node(s) connected to that node, then the nodes connected to those nodes, etc.?

How is this possible?

Answer 1

The python path to the links between each node is

bpy.data.materials[].node_tree.nodes[].inputs[].links[].from_node

So for each material we want to start at the Material Output node then loop through each array of inputs[] and links[] to move through the connections. Going this way (using from_node) there should only be one link for each input, but if you want to reverse the order (by using to_node) you can have multiple links for each output.

import bpy

def followLinks(node_in):
    for n_inputs in node_in.inputs:
        for node_links in n_inputs.links:
            print("going to " + node_links.from_node.name)
            followLinks(node_links.from_node)

for mat in bpy.data.materials:
    print("Traversing " + mat.name)
    for mat_node in mat.node_tree.nodes:
        if mat_node.type == 'OUTPUT_MATERIAL':
            # we start at the material output node
            print("Starting at " + mat_node.name)
            followLinks(mat_node)

Answer 2

Hello from 2024.

Here's a non-recursive (as in the function doesn't call itself over and over. Nodes are retrieved recursively through a stack), customizeable variant. Works with the latest Blender (4.1.1), can traverse insanely large materials.

Basically, this is a "pro" way of traversing trees. Hope this helps.

import bpy


# material =       Material to traverse
# starting_point = Start at this node
# yield_reroute =  Whether to yield reroute nodes

# 'material' can be none, if 'starting_point' is provided
def walk_node_tree_backwards(
    material=None,
    starting_point=None,
    yield_reroute=False
):
    # Realistically, most materials only have one 'Material Output'.
    # Don't traverse potentially large trees twice, if possible.
    root = starting_point or material.node_tree.nodes.get('Material Output')

    # Couldn't get the starting point node the easy way.
    # Find the material output manually.
    if not root:
        for node in material.node_tree.nodes:
            if node.type == 'OUTPUT_MATERIAL':
                 root = node
                 break
    
    # If still no starting point - give up
    if not root:
        raise LookupError(
            f"""Could not get the starting point. Current starting point is: >{root}<. """
            f"""There's either no starting point in material >{material}< """
            f"""or provided starting point >{starting_point}< is invalid """
            """OR BOTH material and provided starting point are somehow invalid..."""
        )

    # Walk DOWN the tree
    stack = [root]
    while stack:
        node = stack.pop()

        if node.type == 'REROUTE' and not yield_reroute:
            pass
        else:
            yield node

        for input in reversed(node.inputs):
            for link in input.links:
                stack.append(link.from_node)


if __name__ == '__main__':
    # Sample usage.
    
    # Go through every material in the blend file.
    for mat in bpy.data.materials:

        # A material can be not node-based
        if not mat.node_tree:
            print(f'=== Material >{mat.name}< is not node-based. Skipping ===')
            continue

        print(f'=== Traversing >{mat.name}< ===')
        for node in walk_node_tree_backwards(material=mat):
            print('\t', node)