Most Shopify developers will already be familiar with the “Shopify API”, or Application Programming Interface. API usage has emerged as a common trend in the development world, allowing creators to easily add additional functionality to a range of projects.
The Shopify API, like any Application Programming Interface, is a convenient resource allowing developers to bring all kinds of features into Shopify stores and website. However, as a store continues to grow in complexity and size, developers need to ensure they’re using the API wisely.
If you’re new to the Shopify development world, or you’ve only recently started experimenting with the API, here are some tips to keep in mind as you create.
- Create a Usage Plan for your APIs
The first step in optimizing your API strategy is deciding how you’re going to interact with your APIs. This means creating a plan for usage. Whether you’re building an app or a website, knowing how you’re going to leverage each tool is essential.
An effective API usage plan should include a clear overview of what tasks need to be done, like making product updates, inventory updates or processing orders. You’ll also need to estimate roughly how many API calls it will take to complete each of these jobs, and how often you’ll need to run each “job” or task type.
Shopify built it’s API for quick data extraction, but most updates will require an API call for every product or item being updated. For instance, updating all 1,000 products in a store would take 1,000 API calls, because you need to complete the process one at a time.
- Use Concurrent Scheduling for Jobs
To help manage API usage effectively, you’re going to need a scheduling tool. Ideally, you’ll want to make sure you can use this service to run jobs in the background of the store, and even run multiple tasks at once, retrying jobs that may fail as you go.
Running jobs concurrently will safe you a lot of time as a Shopify developer, compared to running everything as a series. While the Shopify API supports 2 call requests a second, the leaky bucket formula allows bursts for up to 40 API calls.
The scheduling system you use will depend on your coding language. Ruby fans generally appreciate the functionality of tools like Sidekig.
- Synchronize Requests around a Call Budget
When you run various jobs concurrently as part of an API development strategy, each job will consume one of the API calls in your budget. While some developers continue running calls until they receive the “429 – Too many requests” error, this isn’t the most efficient strategy.
Instead, it makes sense to use a shared counter to track your remaining calls as they tick down. This should prevent you from wasting time and resources by sending requests to Shopify which can’t be fulfilled. Each API call should be able to:
- Check the remaining API call budget
- Decrement the remaining shared budget
- Set the shared remaining budget based on Shopify responses
You can use Ruby and Sidekiq for this, or access a tool like Redis to track your budget counter.
- Be Efficient with Job Scheduling
Any great Shopify developer knows efficiency is key to achieving excellent results at speed. Although it might take a little time for you to become as efficient as possible with your API practices, there are some steps you can take to optimize your API experience.
For instance, you can enhance your API call budget by starting jobs during different time blocks, and grouping smaller and faster jobs together. It also makes sense to keep slow and larger jobs separate, so they can take full advantage of the complete API limit.
Clearly planning, prioritizing, and scheduling your jobs with a focus on efficiency should make it easier to spread your workload evenly throughout the day. Keep in mind, one group of jobs should always be finished before you begin the next, or you might end up with an unreasonable queue.
- Request Only What You Need
Using the Shopify API involves requesting data from Shopify regularly. However, to run the most efficient development process, you’ll need to ensure you’re not making requests unnecessary. Instead, ask only for the specific elements you need when you need them most.
The majority of API list views come with a “fields” section so you can limit the information you collect. For instance, you can request just the values for a list of Product IDs and prices. By refining the information, you ask for, you’re reducing the strain on the system. When less data needs to be sent back to you, you should receive insights faster too.
Because you’re putting less work on Shopify, you should find the clock times required to run each request is a lot shorter, which should also improve your API budget.
- Only Send Shopify Fields That Have Changed
When making updates via APIs, it’s important to make sure you’re not sending more information than Shopify needs too. This is another way to reduce the strain on the ecosystem and speed up performance. For instance, if you just need to update some information about variants in an inventory group, you can adjust your request to send just the variant ID and quantity information.
Shopify’s API also allows you to “batch update” variant information for products, which means you can reduce the amount of API calls you need to make.
The less data you need to send, the faster your API calls will be, because Shopify doesn’t have to do as much work changing records in its database. This process also means you can cut down on the number of image URLs you send to Shopify, because image processing generally takes more work.
- Be Cautious with Data Storage
Shopify is a powerful tool for developers, designed to make a lot of processes easier. The ecosystem streamlines the retrieval of data, but you still need to use an API call for every item you update when you’re updating a Shopify store. This means you might need to make a lot of extra API calls to update every piece of data in your environment.
It’s important to reduce the number of additional calls you need to make wherever you can. You can do this for watching out for common issues, like storing data in too many places. Metafields, for instance, allow users to store additional data in multiple locations throughout the Shopify API.
Adding Metafields to 1,000 products with five variants would mean you need to make 5,000 API calls for each Metafield, increasing your strain on the API call budget. However, you can always use a JSON Hash within your product metafield to overcome this issue.
Mastering the Shopify API
Like anything else in the Shopify development world, mastering API usage is a process which requires some time. You’ll need to create effective plans for how you’re going to use APIs, schedule your jobs effectively, and make sure you’re only requesting and sending data as needed.
As the Shopify world continues to evolve, there’s a good chance you’ll find yourself needing to update your API skills. However, for the meantime, the tips above should help you to get more out of your API functionality.