There are many great commerce solutions out there. Everywhere you look you’re faced with new technology, new ideas and new approaches on how to best grow your transactional business. It can prove tricky to take an informed decision and know what’s best for your needs. Today we’re going to take a closer look at embeddable checkout experiences on the market.
We’re not here to tell you why the Moltin embeddable cart and checkout (Shopkit) is right for you. We’re here to compare some of the top solutions on the market - created by Shopify, Snipcart, Shoppable and Moltin so you can make the best choice for your needs.
We’ve gathered some of the most prominent features of the four solutions to give you an idea of the similarities and differences of each one, and hopefully make your decision a bit easier. We’re going to expand on some of the most important aspects below in the post.
|Customizable cart and checkout||YES||Limited||YES||YES|
|Control over the checkout flow||YES||NO||NO||NO|
|All transactions done on the merchant’s site||YES||NO||YES||NO|
|Abandoned cart recovery||YES||*NO||YES||Limited|
|Few lines of code||YES||NO||YES||YES|
|Secure online transactions||YES||YES||YES||YES|
|Integration with any third party payment gateway||YES||NO||**NO||NO|
|Works with any product catalog||YES||NO||YES||YES|
|Address Lookup||YES||NO||YES||Existing customers only|
|Programming skills required||NO||NO||YES||YES|
* excluded from the basic pricing plan for this feature
** coming soon (currently supports 9 gateways)
Few lines of code
The best solutions are backed with a clean and elegant codebase that is easy to customize and doesn’t put strain on the existing system. Snipcart’s solution is easy to embed as the entire functionality is based on a few lines of code. Same goes for Moltin Shopkit who’s creator additionally made sure that injecting the cart and checkout experience is so easy you don’t have to have any programming knowledge to make your website shoppable in seconds. Shoppable seems easy enough, but you need to implement code separately for every step of the checkout process - add to cart, checkout the cart, send order confirmation, etc.
Shopify’s Buy Button solution, on the other hand, at first overwhelms with the amount of code you need to add to your website, but overall it is not a bad solution, if you know what you’re doing and have a solid developer background. The concern here would be that this amount of code will significantly slow down page on loading, and that can have detrimental effects during peak sales time, like holiday season or discount period.
Works with any product catalog
Good news to all those who want to embed the checkout feature, but are not necessarily interested in moving their entire catalog over, or want to keep a centralized catalog without the need to create a new one for each solution. With Moltin Shopkit, you can use an outside product catalog, so you don’t have to compromise your omnichannel experience nor your inventory system.
As far as we know, this feature is available only with Moltin & Snipcart. Shopify requires you to create a product using their platform to sell.
Customizable cart and checkout
Both Moltin and Snipcart offer a very well-thought-out customization process for the entire checkout. It’s fairly easy to customize the frontend shopping cart with simple CSS.
Shopify, on the other hand, offers a very limited customization mode, but at the same time keeps it friendly for non-developer folks. You can only customize certain aspects of the cart, like the font size or color scheme. The positive aspect of this limited experience is that you don’t have to struggle with any code, you can do it through their platform by using the WYSIWYG. The downside of this solution is that you’ll need to purchase access to the dashboard separately.
All transactions done on the merchant’s site
Shopify’s checkout process is quite nice and looks very simple to follow. It’s only logical to assume this is a deliberate design aimed at potential customers, especially impulse buyers who are the main target of buy buttons. A simple and hassle-free checkout is the cornerstone of a buy button, it encourages to buy a product and doesn’t leave room for buyer’s remorse.
While we applaud Shopify for their very well-designed checkout, we should also stress that the checkout is not as streamlined as it could be. The cart and checkout itself are separated, and once a customer clicks checkout, another popup opens up, where they can finish their transaction. The main issue with this approach is that, depending on the Internet bandwidth, it can slow down the entire process, as it happens through a brand new URL that needs to load the next checkout step. It also takes a consumer out of the environment they were in, causing frustration and potential cart abandonment if they do not trust the URL or source they are taken into to complete the checkout process.
Same goes for Shoppable. Their checkout process takes you through different URLs, before you land back on the merchant’s site. The “Thank You” screen is a nice touch, but even though it’s the site you originated from, you’ll need to navigate back to the product catalog, if you have more shopping to do.
Both Moltin and Snipcart catered for this slightly choppy user experience by placing the entire process within one window, embedded right there within the merchant’s site. The buyer doesn’t have to leave the native environment, and in the case of the Moltin feature, the checkout appears on the right side of the screen obscuring only part of the original content.
Control over the checkout flow
Both Shopify and Snipcart offer great products, but they seem to lack certain flexibility. Talking here about the lack of control over the checkout steps. The checkout is fixed in both cases. It’s impossible to change the preset order of customer details, billing, shipping, payment, etc. which is absolutely fine if you want to keep your checkout in the way they have laid out the experience. However, if you do know your customers prefer checkout steps in a different order to the norm, then Moltin Shopkit may be the right choice for you. With Shopkit you have full control over the checkout steps, and it’s you who decides how you want to structure your checkout experience.
Moltin Shopkit allows for customer login. This means that any returning customers can log in and view their details: cart’s history, orders, payment method, and stored addresses. This also means that you can empower your customer to make the checkout flow even more hassle-free by pre-populating all fields with necessary details. This is an amazing news to all those who want to challenge Amazon and their one-click shopping feature.
Shoppable offers a similar but limited solution. It allows already logged in customers to benefit from a simplified checkout process. There is no previous order history to view though.
Moltin uses the Algolia Places API for address lookup. All customers, not only the logged-in users, can streamline their checkout process with the easy-to-use address lookup that automates the tedious process of inputting the billing and shipping address details.
The only other solution that includes a similar feature is Shopabble who allows for customer login to pre-populate addresses, so that the checkout process is less laborious and time-consuming.
Abandoned cart recovery
All solutions mentioned in this post offer some abandoned cart management, which differ from solution to solution. It’s a bit tricky with Shopify, as it is only available if you opt for an upgraded pricing plan, rather than their base one. Snipcart gives you a list of abandoned carts, so you can contact your customers and prompt them to buy the product in a series of nurturing emails and their widget has this baked right in too.
Shoppable allows you to retrieve an abandoned cart stored as a cookie, but it’s per userID, so there’s a lot of work involved.
Moltin, on the other hand, offers persistent carts. If for any reason your customer leaves your site, their cart will be stored for them when they return. Not saying it’s necessarily better, but for sure it’s the easiest approach taken.
Each solution presented is great to use in different scenarios. Shopify is good for all those who don’t mind a standardized approach to the look and feel of the feature, but at the same time would like to have one dashboard from where they want to take control over their products and available features.
Snipcart and Shoppable are great for developers. Their solutions are very friendly and give a developer a lot of freedom to implement the feature how they want it. But you need to have a very good set of developer skills to be able to implement their solutions seamlessly.
Same can be said for Moltin. The solution is lightweight and highly customizable, but at the same time it’s so simple it can be implemented by anybody without the constraints of any development background. Having a full headless commerce API backend, it is also fully scalable and will grow together with your business by allowing you to upgrade to a more robust commerce site experience or expand your commerce use cases as and when you decide you want to.