How to support two licensing mechanisms in single plugin?

How can we support Marketplace licensing and our custom licensing mechanism in a single plugin?

Currently, it seem that we are locked into Marketplace licensing as soon as we add <product-descriptor> tag to plugin.xml and use a IntelliJ IDEA edition/version that supports Marketplace licensing (e.g. Ultimate 2019.1).

IntelliJ IDEA Ultimate asks at startup whether:

  1. activate plugin using purchased Marketplace license
  2. evaluate for 30 days
  3. disable plugin

So there seems to be no way to use our custom licensing mechanism.

The situation is different when using Community Edition or older Ultimate versions, which do not support Marketplace licensing. Then our custom licensing works fine (and is required in this case).


I've seen the article "Moving to the marketplace from other licensing/billing solutions" at, but I think that the three suggested migration paths are either not practical in our case, complicated or too time-consuming. In all suggested cases the end-user (customer) has to do something to change licensing, which is IMHO bad user experience.

Our preferred Marketplace migration path would be:

  1. end-user (customer) can continue using existing license keys as long as they are valid
  2. if end-user wants to upgrade to latest plugin version, he should start using Marketplace licensing


Our product JFormDesigner is also available as plugin for other IDEs (Eclipse, NetBeans, etc) and as StandAlone edition. The end-user can use all editions with a single JFormDesigner license key. We have customers where some team members use IntelliJ IDEA and some use other IDEs. Some use Ultimate edition, some Community edition.

So we'll continue to sell JFormDesigner licenses in our store and those license keys must work in all JFormDesigner editions including the JFormDesigner plugin for IntelliJ IDEA.

For customers that use IntelliJ IDEA Ultimate only, we'll recommend them to use the JetBrains Marketplace (in this case they can not use the other JFormDesigner editions).


If there is currently no solution for dual licensing mechanisms, would it be possible to add a flag to <product-descriptor> tag (or somewhere else) to not disable plugin at startup and enable custom licensing mechanism? E.g.

 <product-descriptor ... allow-custom-license-manager="true">

If the flag is true, in the "Plugin JFormDesigner License Activation" dialog (which pops up at startup), the "Disable plugin" button could change to e.g. "Use plugin vendor licensing" button, which keeps the plugin enabled. Then the plugin is responsible for license checking.


Another solution would be to implement two plugins:

  • existing plugin "JFormDesigner" that uses our custom licensing mechanism
  • new plugin "JFormDesigner Marketplace Edition" (depends on plugin "JFormDesigner") that uses JetBrains Marketplace licensing

I think this should work with the current IDEA versions, but has the disadvantage that the end-user has to install two plugins...


Any other ideas?


I am also interested in this for the same reason as above and the fact that an unlicensed copy of the plugin presents limited functionality instead of being disabled.

Effectively solving the latter allows implementing an alternate licensing scheme--if JetBrains Plugin Marketplace license is not available then the plugin can check for legacy licensing and finally fall back to limited functionality.



Any update on this?


>In all suggested cases the end-user (customer) has to do something to change licensing, which is IMHO bad user experience.

We couldn't find any way which would make it possible to change the licensing with 0 involvement from the user, and I agree about the experience, but the user has to give a consent somehow that they are OK with it (and without the explicit consent we are legally not allowed to switch the license.) If you have some suggestions on how else it can be done, we are ready to discuss it and try to make it happen.

So far we can't support two licensing mechanisms in a single plugin. In theory, we could have implemented a `product-descriptor` workflow you suggested, but it is the first time we get this request, so we hardly can push it to 2019.2 major release, and definitely not before the end of June when we would like to start sales of the plugins, as it would require some time to design and implement it.

By the way, for the IntelliJ IDEA Community and other free versions of the IDEs, you can issue two different updates with two different licensing schemes (Marketplace for Ultimate, Legacy for Community) defining different compatibility within the single plugin. But it would hardly help with the migration - there will be still the moment when the users have to be switched somehow, and again - it would be hard to do so without their consent. I would recommend setting some version of the plugin when you require them to use Marketplace (= switch the license.)

The option with two plugins might work as a workaround, yes, but it doesn't look like good user experience and might be confusing for the users.


I have this same question. I've been speaking with Mikhail about the marketplace since the very early days, and I'm hugely impressed that it's all real now, but I'm struggling to understand how I can get from here to there.

I have several years' worth of accumulated users on the current purchasing and licensing solutions, and I don't want to make the renewal cycle any more confusing or difficult for them than it needs to be. I also don't want to have to maintain two different versions of the product against two different purchasing/licensing's already a non-trivial effort to manage the existing solutions.

I also can't imagine what it would look like for a customer with some subscriptions on the existing purchasing/licensing solutions who wants to add new licenses. Does that force a migration to consolidate onto the new solution, or do they end up with some licenses/subscriptions from the old solutions and some from JetBrains marketplace? Neither seems like a good option.

I'm curious as to how others are doing this. I can't really consider moving over until there's marketplace support for Community Edition IDEs anyway, so I figure now is as good a time as any to start harvesting the experience of those who have been-there-done-that.

Thanks in advance for any insights you can provide!


Thank you! That is a really valuable post (and comments as well). I had experience with creating the Wordpress plugin.


It looks like you can now set optional="true" in the product-descriptor in plugin.xml then end users can install the plugin without buying a license from JetBrains. You can then check for either a JetBrains purchased licensed or a license obtained another way and unlock the features that the users are entitled to.

It doesn't seem intended for exactly this use case, but it looks like it will work. More details here

I haven't seen an example of what this looks like in the store - I don't know if you get an extra option alongside "30 day trial" and the subscriptions to just install it, or what.