Were you to send a bare request from commandline:
curl -X POST \
-H "Authorization: Bearer your_actual_token_here" \
-H "Accept: application/json" \
-d '{"objects": ["validObjectId1"]}' \
https://app.speckle.systems/api/getobjects/6a87e55c77
Do you still see the same?
Yes
curl -X POST ^
More? -H "Authorization: Bearer my_token" ^
More? -H "Accept: application/json" ^
More? -d "{\"objects\": [\"cf02d5566caa6c38c3e2a7d9154168f4\"]}" ^
More? https://app.speckle.systems/api/getobjects/6a87e55c77
{"error":{"message":"Unexpected token u in JSON at position 0","code":"SyntaxError"}}
The curl statement should have included the Content-Type header to send the data in valid format:
curl -X POST \
-H "Authorization: Bearer my_token" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-d "{\"objects\": \"[\\\"cf02d5566caa6c38c3e2a7d9154168f4\\\"]\"}" \
https://app.speckle.systems/api/getobjects/6a87e55c77
Note that the content of objects should be a string, not a JSON object.
In Python, I think this would be:
body = {
"objects": "[\"objectId1\", \"objectId2\", \"objectId3\"]") # Example IDs in JSON stringified array
}
When adding the Content_Type -key i get the following response:
{“error”:“Your token is not valid.”}
Is it true that i need to use an acces token as generated in this section:
Yes. Please create a new access token with at least streams:read scope to use the /api/getobjects API paths.
You may need other scope depending on any other paths you wish to use your token for, e.g. streams:write if you intend to send objects to Speckle.
The Access Token is a secret and should not be shared with others.
Iain
@jonathon and @iainsproat, I seem to get a little bit further. With the code down below i got a valid “200” status_code. The issue now is that i now get an empty list where i was expecting data.
header={
"Authorization": f"Bearer {Token}",
"Accept": "application/json",
"Content-Type": "application/json"
}
body = {
'objects': ['"cf02d5566caa6c38c3e2a7d9154168f4"']
}
url_get=f"https://app.speckle.systems/api/getobjects/{IN[0]}"
with requests.post(url=url_get,headers=header,json=body,stream=True) as r:
OUT=r
Its unclear to me if i need to use the model URL or Project URL (custom property - Speckle test kolommen | Speckle) (Speckle test kolommen | Speckle) when trying to extract an object.
Also is this the right id to take:
present in the body?
if IN[0] is the project id, then this should be returning the object you highlighted
This is the case so something is still going not quite right since i’m getting an empty list as response
Hey Jonathan, do you maybe have an idea of how i could decipher if there is a bug in the API? It seems now that the script should return an object but what i get is an empty list. At this moment i have no clue how to check where the problem lies. I’m hoping you can give me some direction of how to figure out whether this is a bug or a mistake in my script?
TBH i wouldnt try to download a stream with the REST API from python, id go straight to using specklepy.
import os
from dotenv import load_dotenv
load_dotenv()
token = os.getenv("SPECKLE_APP_TOKEN")
server = os.getenv("SPECKLE_APP_URL")
project_id = "6a87e55c77"
from specklepy.api.client import SpeckleClient
client = SpeckleClient(server, use_ssl=True)
client.authenticate_with_token(token)
from specklepy.transports.memory import MemoryTransport
from specklepy.transports.server import ServerTransport
project = client.stream.get(project_id)
model_id = "58c8effef5"
branches = client.branch.list(project_id)
model = next((b for b in branches if b.id == model_id), None)
latest_version = model.commits.items[0].referencedObject
memory_transport: MemoryTransport = MemoryTransport()
server_transport = ServerTransport(project_id, client)
data = operations.receive(latest_version, server_transport, memory_transport)
from collections.abc import Iterable
from specklepy.objects import Base
def flatten_base(base: Base) -> Iterable[Base]:
"""Flatten a base object into an iterable of bases.
This function recursively traverses the `elements` or `@elements` attribute of the
base object, yielding each nested base object.
Args:
base (Base): The base object to flatten.
Yields:
Base: Each nested base object in the hierarchy.
"""
# Attempt to get the elements attribute, fallback to @elements if necessary
elements = getattr(base, "elements", getattr(base, "@elements", None))
if elements is not None:
for element in elements:
yield from flatten_base(element)
yield base
list(flatten_base(data))
# [
# Base(id: 06c616f7b25acde87dbd54135b0c04da, speckle_type: Objects.BuiltElements.Column:Objects.BuiltElements.Archicad.ArchicadColumn, totalChildrenCount: 0),
# Base(id: f2226f1bec2c8c51163abfe446f98e17, speckle_type: Objects.BuiltElements.Column:Objects.BuiltElements.Archicad.ArchicadColumn, totalChildrenCount: 0),
# Collection(id: f99160be5076719329a34f7b68459da7, speckle_type: Speckle.Core.Models.Collection, totalChildrenCount: 0),
# Collection(id: 71ecb27730fd332e5ff9a7d4bd341b71, speckle_type: Speckle.Core.Models.Collection, totalChildrenCount: None)
# ]
Thank you very much Jonathan! this is very helpfull. I tried this as well in dynamo for Revit. The problem i have here happens at the statement:
project = client.stream.get(project_id)``
Giving the output:
Failed to execute the GraphQL stream request. Inner exception: Transport is allready connected.
Before we start to tackle this problem, maybe it would be helpfull to explain a bit off what im trying to do. I want to make a custom connector In Revit/Dynamo which will be able to get elements in an sends them back with the same id. The goal is to maintain the element traceability throughout the whole proces, even when it gets modified in different software. The documentation stated:
When working with uploading and downloading objects, the REST API is preferred.
Is the GrapQL the right approach for this usecase or is the REST API the way to go for this usecase? I’m still figuring out the landscape of connection options in Speckle. I have tried the built-in Speckle 2 Connector in Dynamo but with that approach i didn’t seem to get all data neccesairy. I’d like to get your opinion about this. Thanks again in advance! The help i get on this platform is great!
I’ll check with the team internally, but in my experience/view, updating objects with the same ID directly is possible, yet it is considered unSpeckle-like. That is not to say it is illegitimate, but it is not the direction of travel we have for our demonstration of Speckle.
That’s a lot of words to say; I disagree with what you found in our docs 
A colleague has pointed out an issue you maybe facing due to the embedded dependencies in Revit/Dynamo
Indeed, I had a similar experience working on the FME connector.
The updating objects with the same ID isn’t something i read in the documents but just a usecase i’m working on at the moment (so no fault there on the Speckle-end 
). The reason i’m interested in this idea is because of the following situation:
Lets say an architect models a certain wall in Archicad. After that, the structural engineer imports that wall into Revit and adjust some parameters and maybe also some of the geometry. When importing that same wall back into Speckle, it is no longer recognised as the same wall.
This situation affects the tracebillity of the object througout the design proces. What we are now trying to explore is if we can use Speckle in a way were we can still track the changes of certain objects over multiple transfers between different software. The goal here is that we can later use this data to optimize our designproces.
Maybe updating the object to the same id is not the right way, but thats the approach which came to mind with my (still limited) knowlegde of the Speckle ecosystem. Do you know if there are allready other functionalities available which we can use to track the changes of objects over multiple transfers through different software?
Ah, the ID problem. It is much debated. A universal UID for objects externalised to the database and the authoring application—now that’s Strange Matter territory.
But before diving into solutions, it’s worth asking: Why is tracking an object across tools and versions essential to your current challenges? Is this driven by:
Or is it a more theoretical exploration to future-proof your workflows? If theoretical, it’s worth examining whether it aligns with Speckle’s capabilities, as universal object tracking often introduces practical complexities. Speckle’s versioning and metadata features might already meet your needs more simply.
By default, Speckle handles object identification in two ways:
applicationId: Assigned by the host application:applicationId to a hierarchical path index. This is inherently software-specific and breaks when the object moves between platforms or is multi-authored.speckleId: A hash based on an object’s content (geometry, metadata, etc.), unique to its exact state at the creation time. Any modification—intentional or software-induced—generates a new ID.Thus, neither applicationId (software-specific and mutable) nor speckleId (content-based and immutable) can reliably track objects across versions or tools.
applicationIds are tied to the originating software, lost or altered when objects are transformed.applicationIds, further compounding the issue.globalId or Custom Properties:applicationId, globalId) and establish traceability.Speckle is designed to share, version, and collaborate on data, but its IDs focus on immutable snapshots rather than evolving object tracking. Cross-software traceability requires leveraging custom workflows, metadata, or middleware. If this challenge is critical, we can explore tailored approaches to your needs.
Hi @jonathon,
So our the reasons we want to track an object across tools are:
The workaround we wanted to apply is:
applicationId, globalId) and establish traceability.So in this thread we have discussed the REST-api, the GraphQL-api and the builtin speckle module in dynamo. Also i see that Speckle Automate might be an option. We would like to develop a durable workflow. Which of the the options spoken of above would you recommend to start with?
@jonathon @iainsproat, I still encounter several problems but trying to get the objects with all of their information into dynamo for Revit with SpecklePy. But to know which problem to solve i first am trying to find out which approach would be the right one in regards to the usecase as describes above. Could you help me out please?
Hey @DonnyRH
since any speckle object (that inherits from specklepy.objects.base:Base) supports dynamically attaching arbitrary arguments, you can start experimenting with attaching your own data conventions to any objects you receive / create locally and then send to the server.
For all object-tree related actions we highly recommend using operations exposed in specklepy ie specklepy.api.operations:send, :serialize.
So if I understand your flow correctly, you are producing data somewhere, which you want to receive and manipulate in dynamo. I think running specklepy in dynamo might running into some dependency conflicts, as noted by Kateryna.
To confirm, that your script does what you need, i recommend running it in a standard python environment outside of the (many times weird) dynamo python environment.
Hope this helps.
Hi Gergo,
Thanks for your reply. The flow i want to implement is as follows:
The goal is to find a way to be able to trace an element throughout the whole design-cycle. In this flow i made the assumption that it would be possible to map a native element to a speckle element by some kind of id-attribute. Basicly i would like to make a custom connector for Revit which doesn’t port elements back as Revit elements. At the moment i don’t know which of the systems suits this case best (REST-api, GraphQL, Dynamo-connecter, Specklepy etc.). So if i understand correctly i need to pay special attention into setting up the environment in a dynamo python environment and the Base-object is the entity which ties native-objects to speckle-objects (please correct me if i’m wrong). Before i start experimenting with the different communication-systems, could you advise me from your point of view which of the systems (REST-api, GraphQL, Dynamo-connecter, Specklepy etc.) is by design best suited for this usecase (or direct me in other utilities Speckle might have to have more control over the attributes while transporting elements)?
Hey Donny,
as mentioned above, any time your are trying to do anything with Speckle objects, its highly recommended to do it via one of our SDK-s.
As for your workflow, its been a while since I done hacking on revit data in anger, so I might be wrong, but it sounds like you need to bake a custom parameter to all of your revit objects, that allows you to assign this uniqueId.
Our connectors (with the right settings) fully support parameter extraction and baking on send and receive, but you’d have to wire up this custom parameter logic yourself.