Communicating between Prototype and Figma Plugin

Plugins cannot run in Presentation mode, and therefore receive changes from the prototype.

is this still the current behaviour? or can the plugin API already access the prototype variable values?

Hey @xiduzo, thanks for following up!

This is still the expected behavior. Plugins do not run in Presentation mode.

I’d like to request enabling plugins in prototype mode. I’ve been working on a plugin called Punchcut Audio Player that allows users to prototype audio in design mode, and we’ve received numerous requests to extend its functionality to prototype mode as well.
Prototypes are becoming more than a click-through of screens. We’re using them as story-telling tools, interactive exercises for user research, and demonstrations of multisensory/multidevice systems. With the addition of variables, prototypes could evolve even further.

Given the current limitations of prototypes, my team is looking to other tools and workarounds to keep up with our changing prototyping needs, but we do want to stay within Figma.

Over the past 2 years, it looks like others have been requesting features that would be solved by this as well:
Audio In A Prototype
Voice Prototyping On Figma
Give Us A Way To Snapshot Prototypes And Send Snapshot Links
Bringing Automated Testing To Figma Prototypes
Communicating Between Prototype And Figma Plugin
Feature Request Prototype Integration

The endless possibility and flexibility of plugins in design mode is what makes Figma stand out as a tool and we would love the same empowering capabilities in prototype mode.

This would be a game changer on so many levels. 🤞🏾

I agree. I’m also making a usability test plug-in using AI… Compared to the original features of the AI model I’m based on, this Figma flog-in version remains at a very low level of simply analyzing only one page due to API limitations.

I hope that Figma can obtain information from the prototype screen as an API, and release a new API that can manipulate the screen instead.

klever - Instant Usability testing – Figma

Original AI model(Python)

Hey ​@dvaliao, I think my last reply was taken away due to the migration to the new forum (love it by the way) and me not reading the huge banner on top. User never read right :p

Anyway, I was wondering if this is something which is being noticed as a actual bug?

I can see that plugins, like https://www.figma.com/community/plugin/1355055910166329140/variables-inspector, are using the https://www.figma.com/plugin-docs/api/properties/nodes-setboundvariable/ API to actually get updates from within the presentation mode.

This to me indicates that Figma has access to these variable changes from within the presentation mode, however slightly limited, and it would be wonderful for plugin developers to gain access to this as well!

I can imagine extending the current variable API with `.getPreviewVariablesAsync` similar to https://www.figma.com/plugin-docs/api/properties/figma-variables-getlocalvariablesasync/ or `.getPreviewVariableByIdAsync` like https://www.figma.com/plugin-docs/api/properties/figma-variables-getvariablebyidasync/.

Curious to hear your thoughts on this or any update regarding this issue!

+1 on this feature.

I am developing a plugin which allows users to directly integrate their designs with hardware components. Getting “data” into Figma and setting variables is super easy thanks to the current API. Any changes in the “real” variables will reflect in the prototype/preview.

Getting “data” out however is impossible unless hacked together. Right now I am asking from the users to open a link in their prototype to my website containing both the variableID and the desired value. I am picking up this request and then send this value back to my plugin and from here on it will update the prototype/preview. This is super cumbersome and while running workshops it is super confusing to the people using the plugin.

It would be amazing if we can “just” have access to the variable values from within the preview mode, similar to the access we have of the variables in design mode, and listen to changes over here. This will also allow for more advanced prototyping and fully utulize Figma and its’ prototyping with variables without having users to leave Figma just to come back to see the update.

Any update on this would be greatly appreciated!

Hi @xiduzo, thanks for replying again!

Yes - it does seem that your last reply was lost in the migration, but glad to hear you’re loving the changes. 😁

I took a look at your linked plugin, and yes - you can use a plugin in editor mode, so that your changes can/will appear in real-time to viewers of a presentation. That’s how the plugin you’ve linked is able to been seen in prototype mode. But keep in mind, there is still no way to run a plugin in presentation mode, so this is still expected behavior rather than a bug.

As shown in their YouTube demo, they run the plugin first in editor mode then switch to view the frame running the plugin in presentation mode. Again, you can’t “run” a plugin in a prototype itself, but you can always run them in a separate Figma edit window and still see it if set up to be visible within presentation mode. Hope this helps clarify! 

Thank you for your quick answer,

I think there might be some misunderstanding of what I am asking here.

I would like to know if it is possible to gain access to the variable values from the running preview mode. And if not, is there any feature plans to allow this in the (hopefully near) future?

I understand that, as of right now, you are not able to run the plugin directly inside of the preview mode, this is not what I am asking for.

However, I can see that the preview mode does react to changes of variables from the editor mode (your local variables) and the preview mode does have some way of updating values bound to variables (like the linked plugin is doing).

It does not make sense to me that my plugin, which runs from the editor mode, can affect variables in the preview mode by editing the local variables via the API but that same plugin does not have any access to see what are the values of that running preview.

For example;

I made a simple shopping cart page with some prototyping logic that calculates the amount of items the user has added to the cart (using variables) and based on the items price (using variables) I can calculate the total shopping cart amount (again, using variables). With all of this neat prototyping I can update the UI perfectly by linking text frames to the above mentioned variables.

Now, I would also be interested, from my plugin running in editor mode, to see the current state of the variables of the preview mode, not just of the local variables I have declared (which do not update from prototyping interactions).

I hope this clarifies the issue and I am looking forward to your response!


Cheers

Thanks for clarifying, ​@xiduzo! 

I’ll pass this onto our variables team for more input. I’ll follow up with an update, if this can be added to the future roadmap. 

hey ​@dvaliao, any update on this issue?

If you need any more input or clarification, do not hesitate to reach out to me!


Cheers

​@dvaliao has this landed in the variables team? Is there perhaps any expected timeline for this or is this a feature that will “never” be added to Figma?

Seeing the following post on the forum I can see there is a broader need for this, any update would be very helpful!

Hey ​@xiduzo, thanks for following up! 

Right now, this is a systemic limitation to how variables/plugins/prototyping currently only work in one direction: syncing of editor > preview. Because of this, no plugin running in the editor can truly listen to changes in the prototype. 

The variables team understands that you want to read (temporary) values of variables in the preview mode, but as it stands, there is no syncing of preview > editor; it is a one-way push. This capability would have to be built to function as you’d expect, so while it is now on their radar for the future, we cannot guarantee when/if it will be implemented, which is sadly why I wasn’t able to follow up that it was officially on the roadmap. 

Thank you for the update ​@dvaliao, it is unfortunate to hear that there is no possibility to have this for of synchronisation or any other way to read the (temporary) values from the preview.

As I am truly interested in this feature, I would be interested in any future updates. As I mentioned before, please don’t hesitate to reach out to me! Perhaps my plugin could serve as an example case for such a feature :)

any progres on this? figma feels like an overpriced microsoft powerpoint at this point 

Hey ​@djv - similar to my post 

this is still a concern for people.

Is there any priority given to this at all or are we all too busy with the AI-hype-train and forget to bring actual value to the product?

Hey @xiduzo, thanks for following up here! 

I hear you, and I understand why this continues to be a point of frustration, especially for teams trying to push prototypes further.
 

Just to clarify my role: I’m part of the Community team, so my goal is to advocate for and share community feedback with the product teams, but I don’t directly influence prioritization or roadmap decisions.
 

From what I can share, this isn’t so much about one area being prioritized over another. The limitation comes down to how plugins, variables, and prototype playback are currently structured; specifically, the one-way flow from editor → preview. Because preview state isn’t exposed back to the editor, plugins can’t listen to or react to what’s happening in prototype mode.
 

Enabling that kind of interaction would require more foundational changes across multiple systems (including prototyping and the plugins API/extensibility layer), so it’s not something that’s actively being worked on right now, and there aren’t any near-term plans to support it.
 

I know that’s not the answer you’re hoping for, but I do want to emphasize that your feedback is heard and shared internally. Continued context like this is genuinely helpful in shaping how teams evaluate these kinds of gaps over time.