At Devengo, one important lesson we’ve learned is that outgoing payments aren’t the sole focus of payments automation. Our customers spend a significant amount of time processing incoming payments: verifying the arrival of the money, updating invoices’s status or initiating their business processes once the money gets in.

Incoming Payments are the foundation upon which certain money flow use cases can be built. Here are some examples:

• Invoice or payments reconciliation.
• Collection of payments from clients.
• Aggregation of payments methods.
• Validation of customers account ownership.
• etc.

This is great, but since this is not always related to sales, may time your company doesn’t have the resources or the time for this integration. But the need is still there and In this post, we’ll explore a practical example of how you can automate your applications to react to new deposits in a bank account using the Devengo API.

Before we start

Let’s review two important concepts, especially if you’re not a technical person.

Webhooks

Webhooks are notifications sent by an application via HTTP to alert/notify other applications that something has happened. Unlike a REST API, which allows us to create or read data from an application, webhooks notify other applications of events that have occurred in real-time. You can read more in detail about the utility of webhooks in this post or our documentation.

In this context, we are sending webhooks each time you receive a payment in your account. This webhooks will include all the related information (sender, IBAN, amount, concept, etc).

No-code platforms

No-code platforms are applications to create new applications without writing code. There are no-code platforms to create mobile apps, e-commerce sites or games. There are a specific set of no-code platforms that are focused on enabling the connection of various independent applications very easily, without the need to write a single line of code.

In this case, we’ve chosen one of this last type, called Make.com, but we could have chosen any other platform like n8n, Zapier, or other low-code platforms like Yepcode.

Our Automation

Today we’ll create an easy example where we log each money deposit you receive in your Devengo into a Google Sheet using webhooks and a no-code tool (as said before, Make.com, but you can use any other one).

You could send this information to Office.com, to a database or to any other SAAS. You could also do an automation in the exact opposite direction: send a payment after a business event has been triggered. But again, today, Devengo -> Google Sheet.

The process is something similar to this:

1. A new deposit arrives in one of your bank accounts in Devengo.
2. Devengo sends the incoming payment information to a webhook you have created in Make and added to your Devengo account.
3. Make receives the information, processes it, and persists it to a configured Google Sheet.

Let’s do it

Ok, enough talking, let’s start rockin’!

Creating the Google Spreadsheet

Let’s start creating the Google Spreadsheet where all the incoming payments will be registered. In this case, we are not adding the first row as the header, but you could do it if you want.

Creating a Make Scenario

Once you have created your free account in Make, the first step will be to create a new Scenario. Scenarios in Make are where you define the automation that connects the different applications. For this example, we will create a scenario in which we’ll add two components:

1. The trigger that starts the process will be Custom Webhooks. This will create the URL you will need later to configure your Devengo account.
2. The destination will be Google Sheets. You will need to follow a small guided process to create the connection from Make to your Google account.

Once we perform a test send, we can return to finish configuring the Sheets module.

Creating a Devengo Webhook

Once we’ve created the Scenario in Make and copied the URL from the trigger component, we can add the webhook in Devengo. So we go to Devengo’s control panel and add Make’s URL in the Webhooks section. We will notify that URL when an Incoming Payment arrives.

Although we can notify many intermediate steps (or events in our terminology), in this case, it’s recommended not to subscribe to all events and listen only to the final event: incoming_payment.confirmed.

In order to test the webhook, we’ll make an internal payment between two Devengo accounts to verify that Make is receiving the data. For that, you’ll need to create a Sandbox Account and use our live API documentation. Remember, no-code!

But before creating this payment, we need to get a Devengo Authorization Token that we will use to our our API.

Ok, once we have this token, we can create our first payment payment. This payment is required to finish the setup of the automation in Make. Once it receives a webhook, Make can define the data structure of the payment and complete the configuration of the Sheets module. Don’t forget to run the Scenario for the test to work correctly.

Configuring Google Sheets module

If everything has gone well, Make will have our data and it will know the format of the incoming data so we can easily map it to the columns of our Google Sheets, through its interface.

Putting all together

Finally, we can test the flow by creating a new payment between accounts to ensure that the data arrives in Sheets automatically. Don’t forget to activate the scenario in Make.

Full video

Ok, do you need to watch all the steps in a single video? No Prob, here you are.

What’s Next?

Once you’ve mastered this scenario, you can try other destinations in Make that may be more useful for you. If you have an application with an API, you could even automatically send the information using the HTTP module. The possibilities are nearly infinite!

Any Ideas for your project or company? Do you need help setting up your account? Send us an email and we will be happy to help.