Automate your development process with the App Store Connect API

Welcome. My name is Dajinsol Jeon, an engineer on the App Store Connect team. Today, I would like to introduce updates to the App Store Connect API. Let’s begin.

App Store Connect provides many APIs to automate development processes.

This automation frees your team to focus on what matters most, building great new features for your users.

This year, App Store Connect has significantly expanded its API across key areas like app management and TestFlight. Furthermore, App Store Connect now supports new sets of APIs, which include long-awaited Webhooks API and Apple-Hosted Background Assets API.

Today, I will go over some important and long-awaited updates, such as Webhooks, BuildUpload, and Feedback APIs. But first, let me quickly recap the typical app development process.

App development is an iterative process. You start with new features or bug fixes and upload a new build to App Store Connect.

Once the new build is distributed, your beta testers submit feedback and your next development phase incorporates the feedback from the previous build.

The key is you want to run this cycle as fast as possible. For example, when your users report a crash, you want to fix it as soon as possible for better user experience.

That's where today's updates come in.

The new App Store Connect APIs allow you to automate this loop, enabling much faster iteration.

Let's dive into how.

This year, App Store Connect is introducing Build upload API and Feedback API to support better automation. On top of that, App Store Connect is now supporting Webhook notifications. Your system can get notified when something happens on your app and react to those events.

For instance, App Store Connect will send a Build upload state event to your webhook listener when the processing of the uploaded build is complete. It signals that you can proceed to the next step.

Webhook notifications also support more events, such as Feedback events and Build beta state events, to inform you of important events about your app.

These additions will help make your development cycle faster than before.

Now, let me explore these enhancements in more detail. I will begin with Webhook notifications.

Traditional APIs are like constantly calling someone to ask, “Is there any news?” Your system has to keep asking App Store Connect for updates, but webhooks flip that around.

Webhooks are essentially push communication between servers. Instead of your system always asking, App Store Connect sends notifications about the events.

Technically speaking, it’s an HTTP callback from App Store Connect to your server when a specified event occurs related to your app.

This allows you to build event-driven workflows, which are far more efficient than constantly polling App Store Connect for updates. So, how does this work? Assuming that you have an HTTP server, which will be your webhook listener, you start by giving App Store Connect the URL of your webhook listener, basically telling App Store Connect where to send updates.

Then, whenever a relevant change occurs within App Store Connect, it sends a POST request to your registered URL.

The request payload contains information about the event. Based on that payload, your system can query the App Store Connect APIs for even more information or perform necessary actions. This year, App Store Connect is introducing webhook notifications for important events, new TestFlight feedback submissions, App version state changes, Build upload state changes, Build beta state changes, and Apple-Hosted Background Asset state changes. In order to receive those notifications from App Store Connect, you need to register your webhook listener first. Let me show you how to register your webhook listener in the App Store Connect website.

First, navigate to the Users and Access section. Then select Integrations.

Within Integrations, there is the Webhooks section on the sidebar. Click the plus button. This will open up the panel where you can configure your webhook details.

First, give your webhook a descriptive name. Then, enter the URL of your webhook listener. This is the endpoint where App Store Connect will send the notifications.

Now pay attention to the Secret field, this is important. App Store Connect uses this secret key to sign each webhook notification.

You can use any string for the secret, but it must be known to App Store Connect and you only.

This signature allows your system to verify that notification indeed came from Apple.

Finally, you need to choose which event you want to subscribe to. For today’s session, let me enable Build Upload, Build Beta State and TestFlight feedback events. Click create. That’s it. Now your servers will receive webhook notifications whenever those events occur for your app.

You can also set up your webhook using the API. This approach is particularly useful if you manage many apps or want to register webhook listeners automatically for new apps.

Let me show you how to register a webhook listener with APIs.

To register a webhook listener with the APIs, you need to send a POST request to the webhook endpoint.

The attributes are very similar to what we saw in the UI. You need to send the event types you want to subscribe to, the secret App Store Connect will use to sign the event payload, and the URL of your webhook listener.

Upon successful webhook creation, you will receive a 201 CREATED response. The payload will include the webhook ID, which is necessary for managing the webhook later.

So that’s what webhook notifications are, and how to register your webhook listener with App Store Connect.

Now it is time to automate uploading a new build to App Store Connect using the new build upload API. One of the major enhancements that I’m introducing today is the ability to automate BuildUploads with the App Store Connect API. So why is build upload API useful? The new build upload API is a part of standardized App Store Connect APIs, which allows you to add build upload to the rest of your automation.

This also means that you can upload your build using any language or platform you prefer.

And if you run into issues when uploading, these new APIs provide well-formatted messages to help automate error handling. This gives you a new, more flexible way to automate build upload processes. Let me show you how it works. To upload your build using the new API, start with creating BuildUploads. BuildUploads contain build information such as version and target platform.

Next, provide App Store Connect with the details of your build file using the BuildUploadFiles. App Store Connect will then provide instructions on how to upload your build.

Then, upload your build binary following the instructions provided.

The final step is to let App Store Connect know that the upload is complete so it can start processing the new build.

Now, let me walk you through the API details.

To create a BuildUpload, make a POST request. This request should include bundle version of your build and the target platform. If your request is successful, App Store Connect will respond with a 201 CREATED status with unique ID for this new BuildUpload. The next step is to create a BuildUploadFile to let App Store Connect know the file details. You will need to include the file name, size in bytes, and asset type.

If the BuildUploadFile is created successfully, you will get 201 CREATED response. Inside the response body, you will find upload operations. This tells you exactly how to upload your binary. It gives you the URL to send your build to, instruct you to use the PUT method, and list the required headers.

As with other App Store Connect APIs for uploading files, you might receive multiple instructions to upload your build in multiple chunks if your build is large. In this case, you will need to make multiple HTTP calls with different parts of your binary. After you upload your build by following the instruction from previous response, you need to tell App Store Connect that the upload is actually finished. This step signals App Store Connect to start processing your new build.

To do this, send a PATCH request with the uploaded property true.

If successful, you will get 200 OK responses with the state COMPLETE.

Now, let me open App Store Connect website to see the new build. App Store Connect website indicates that it started processing the new build.

But this raises a key question. When will it finish? And how will we know? That’s exactly where the webhook notification comes in, the one we configured earlier. It will notify you the moment this processing is complete.

Here is an example of what your server receives from App Store Connect when your build is processed successfully.

The key change is the state transition from PROCESSING to COMPLETE. Once you see that COMPLETE status, you have confirmation that the build is processed and you are ready to proceed to the next step. You will also get the message signature in the X-Apple-SIGNATURE header. This tells you that App Store Connect uses the HMAC-SHA256 algorithm.

You can calculate the signature using the secret you set up earlier and the payload body you received, and compare your calculated value and the header value to verify that the notification came from App Store Connect.

That’s how you automate build upload process with the new APIs.

And now let me move on to beta testing with TestFlight. Once your build is processed by App Store Connect, you can use TestFlight to distribute your new build to beta testers. You can assign the build directly to your specific beta tester groups. For external testers, you will need to submit the build for Beta App Review first. Finally, you will want to notify testers that the new build is available. The great news is that all of these steps can be automated using the TestFlight APIs.

These are some of the TestFlight APIs provided by App Store Connect.

You can find comprehensive information in the App Store Connect API documentation. However, the key point I want you to remember is that these APIs empower you to fully automate build distribution to your testers. While those APIs are well-established, I do want to highlight a useful new edition this year, the build beta state webhook event. This new webhook is designed to notify you immediately when TestFlight beta review is complete.

Here is an example payload of a build beta state notification. The payload will show the updated state and include a specific build ID.

When you receive this notification, you know that your build has passed review and is ready for external testing. Okay, so that’s how you can use TestFlight to distribute your new build.

Now, let me talk about getting TestFlight feedback from testers. Feedback is a key part of using TestFlight. Testers can submit screenshot feedback to make suggestion or report UI issues, and crash feedback when they experience app crashes. TestFlight feedback helps you discover insights that drive your app’s evolution.

A fast reaction to feedback is important for a better user experience. That’s why knowing instantly when new feedback arrives is important.

Also, since you don’t want to miss any feedback from your testers, tracking feedback with your development tools is very useful.

To address this, App Store Connect is introducing the new Feedback API along with corresponding webhoock events. This is a long-awaited capability requested by many developers. Let me explore the details.

When there is new screenshot feedback, you will get a webhook notification with a payload similar to this.

The webhook notification contains minimal information. It has the feedback type, which is screenshot in this case, and a related instance.

The instance tells you that it is beta feedback screenshot submissions and gives the ID.

You can use this ID to retrieve the details of this feedback.

When you call the Feedback API to retrieve screenshot feedback, the response you receive will contain various details, including device information and screenshot URL. You can use these URLs to download the screenshot images in separate calls.

Getting crash feedback is essentially identical to getting screenshot feedback, but when the crash log is available, you can download it programmatically by calling crashLog endpoint. So that’s how to retrieve TestFlight feedback using the API.

And that’s how we complete this app development process using the App Store Connect API. Webhook API and events for getting notification, Build upload API for uploading a new build, and Feedback API for retrieving feedback. But there are more.

For example, if you use Apple-Hosted Background Asset, new APIs are available to automate asset management.

And App Store Connect will send app version state webhook events to notify you about state changes of your app in the App Store, completing your process from development, through testing, and finally to release. Moreover, App Store Connect provides many existing APIs to automate different stages of your development process. Again, automating your daily task is important because it allows you to focus more on better user experience.

To wrap up today’s session, here are some recommendations.

First, build webhook listeners so that you can receive webhook notifications from App Store Connect. Next, implement reactive behaviors based on webhook events to automate your processes. Finally, explore what else the App Store Connect API offers and use these APIs in your automation for an even faster development cycle.

Also, don’t forget to check “Discover Apple-Hosted Background Assets” and “What’s new in App Store Connect” session for more information about this year’s edition in App Store Connect. That's all I have for today. I hope you found this session useful. Thanks for watching.