Thank you for reaching out to us. We were not 100% sure in our morning meeting if we understood your question correctly. But I basically understood it as 'how can I find out if a C4DAtom is referenced in a BaseLink in a scene?'. So, to pick an example, you would want to find out if the node A shown in the screen below is linked anywhere in the scene. In that case the answer would be 'yes', since A is linked in a Target Tag of B.

The goal then seems to be to delete such objects which are not referenced in any manner. There are two problems here at play:

1. Abstracted scene traversal, i.e., iterating/recursing over all elements of a scene: The assumption of your code is that a null object is only linked in tags. Which can work when you do not care about other cases of these nulls being referenced. But in practice any form of BaseList2D can hold a link to your null object, i.e., there could be other objects, materials, shaders, etc. linking to that null. To visit each node in a scene you then need such abstracted scene traversal. There are many postings about this subject in the forum, here is for example one. In 2025.0.0 we added mxutils.RecurseGraph which does that out of the box.
2. Figuring out if a given node holds a parameter of type DTYPE_BASELISTLINK which also happens to point towards your null. You can use C4DAtom.GetDescription to look for parameters of a specific type. @i_mazlov has once shown here how this can be done.

There are also some issues with your code, as for example that seems to point into an exponential time complexity direction, i.e., you seem to plan to iterate over all objects in a scene (to find potential objects to remove). That would be very slow.

Find below how I would write something like this. Please note that these scene operation tasks tend to be more finnicky than one usually assumes, so you might have to add features yourself. We cannot debug your code for you or write a solution for you.

Cheers,
Ferdinand

Result

Before:

After:

Code

"""Demonstrates how to search for a scene for nodes that do not appear as links in other objects.

Must be run as a script manager script. Will remove all null objects from a scene which do not appear
as linked objects in other tags or objects (and some other criteria, see main() for details).
"""

import c4d
from typing import Iterator

doc: c4d.documents.BaseDocument  # The currently active document.
op: c4d.BaseObject | None  # The primary selected object in `doc`. Can be `None`.


def Iterate(node: c4d.BaseObject, yieldSiblings: bool = True) -> Iterator[c4d.GeListNode]:
    """Traverses a tree of objects and their tags, yielding each element, including the passed #node.

    I implemented here a traversal tailored to your case. Check out scene traversal threads for more
    abstracted traversal or use 2025's mxutils traversal methods.
    """
    def iterate(node: c4d.GeListNode) -> Iterator[c4d.GeListNode]:
        if not node:
            return
        yield node

        # Yield tags when #node is an object.
        if isinstance(node, c4d.BaseObject):
            for t in node.GetTags():
                yield t

        # Traverse hierarchy.
        for child in node.GetChildren():
            yield from iterate(child)

    while node:
        yield from iterate(node)
        node = node.GetNext() if yieldSiblings else None

def GetLinkedNodes(node: c4d.BaseList2D) -> set[c4d.BaseList2D]:
    """Returns the set (i.e., no repetitions) of nodes this #node has links established to.
    """
    result: set = set()
    for _, descid, _ in node.GetDescription(c4d.DESCFLAGS_DESC_NONE):
        # We found a parameter of type baselink, append the value to the result when it is not null.
        # You might want to fine tune things here, to exclude parameter IDs, e.g., ID_LAYER_LINK, or
        # value types, e.g., c4d.BaseLayer, from being here links you want to consider.
        if descid[0].dtype == c4d.DTYPE_BASELISTLINK and node[descid]:
            result.add(node[descid])
    return result


def main() -> None:
    """
    """
    # Get all the nodes that are somewhere referenced in objects or their tags in the scene. Also
    # store all the nodes which contain links. 
    linkSources: set = set()
    linkTargets: set = set()

    for node in Iterate(doc.GetFirstObject()):
        links: set = GetLinkedNodes(node)
        if links:
            linkSources.add(node)
            linkTargets = linkTargets.union(links)
    
    # Now iterate the scene again, looking for nodes matching our removal criteria.
    result: list[c4d.BaseList2D] = []
    for node in Iterate(doc.GetFirstObject()):
        # Continue when the node is not an object of type Onull, has children, or does appear as a
        # linked node somewhere (e.g., a null object which has a target tag).
        if (node.GetType() != c4d.Onull or node.GetChildren() or 
            node in linkTargets or linkSources.intersection(Iterate(node, False))):
            continue
        
        # This is a node we want to remove.
        result.append(node)

    # Remove the nodes we determined to be removed. We would have broken traversal if we just had
    # removed #node in the loop above, as #Iterate is a generator/coroutine. Removing #node above 
    # would make it a disconnected node and #Iterate would not know how to continue. Could also be
    # solved by first exhausting #Iterate, e.g., `data = list(Iterate(...))`and then iterate over 
    # the result (but that is not so nice performance-wise).
    if result:
        print (f"Removing '{len(result)}' nodes: {result}")
        doc.StartUndo()
        for node in result:
            doc.AddUndo(c4d.UNDOTYPE_DELETEOBJ, node)
            node.Remove()
        doc.EndUndo()
        c4d.EventAdd()
        
if __name__ == '__main__':
    main()