Using icy-tools GraphQL and Remix to Build an NFT Dashboard

Episode Description

Dan from Icy Tools demos the GraphQL NFT analytics API and new React hooks package using a Remix app on QuickNode's Quick Streams.

Episode Summary

In this Quick Streams episode, Anthony Campolo welcomes Dan, co-founder of Icy Tools, an NFT analytics platform recently acquired by QuickNode. Dan explains why GraphQL is a natural fit for blockchain data, noting that the interconnected nature of contracts, tokens, wallets, and logs maps perfectly to GraphQL's relational query model, offering far more flexibility than REST endpoints could. The conversation transitions into a live coding demo where Anthony builds a Remix application from scratch, connecting to the Icy Tools GraphQL API to display trending NFT collection data including floor prices, volumes, and sales figures, then deploys it to Vercel. They then explore a newly launched open-source React hooks package under QuickNode Labs, which abstracts common queries like trending collections and wallet lookups into simple one-liner hooks powered by Apollo. Dan walks through customizing query variables like sort order and time period, and demonstrates the wallet hook by looking up ENS names and displaying owned NFTs. The session wraps with a call for community feedback and contributions to the open-source repo, with Dan emphasizing the mission of making it easier for developers to build in the NFT space.

Chapters

00:00:00 - Introduction and Dan's Background with GraphQL

Anthony welcomes Dan, co-founder of Icy Tools, to Quick Streams and asks about his background. Dan shares that Icy Tools is an NFT analytics platform recently acquired by QuickNode, and that his current focus is building APIs and developer tools in the NFT space.

Dan explains his long history with GraphQL, stretching back six or seven years to when the technology was still new. He recounts first introducing GraphQL at a previous company called Flip (later renamed Caretaker), a real estate startup, where he championed it as an improvement over REST. Over time, GraphQL became his default choice for projects thanks to the excellent front-end developer experience offered by tools like Apollo and Relay, particularly the automatic caching capabilities.

00:03:50 - Why GraphQL Fits Blockchain Data

Dan makes the case that blockchain data is an ideal match for GraphQL's strengths. EVM-based chains contain deeply interconnected objects like contracts, tokens, logs, and wallets, all of which reference each other in complex ways. GraphQL's flexibility allows developers to construct precise, deeply filtered queries rather than relying on dozens of rigid REST endpoints.

Anthony shares his own experience coming from a GraphQL API company before joining QuickNode, noting that most people in the GraphQL community haven't realized how natural the technology is for web3 use cases. The conversation sets up the demo, with Anthony outlining the plan to build a Remix app that connects to the Icy Tools GraphQL API and then explore the newly released React hooks package.

00:07:18 - Exploring the Icy Tools Developer Portal

Anthony walks through the Icy Tools ecosystem, distinguishing between the main dashboard product and the developer-facing API. He shows the developer portal at developers.icy.tools, including the built-in GraphQL playground that automatically embeds authentication credentials, and the example query templates that help new users get started.

Dan explains that the API exposes the same data powering the Icy Tools dashboard, giving developers the building blocks to create their own applications. They discuss authentication details, including the X-API-key header required for requests, and Dan mentions plans to add domain whitelisting so that exposed API keys can't be misused by unauthorized parties.

00:11:10 - Building a Remix App from Scratch

Anthony begins the live coding demo, scaffolding a new Remix application and setting up a queries file to hold the trending collections GraphQL query. He explains Remix's loader function pattern, which runs queries server-side, keeping the API key secure rather than exposing it in the browser client.

The demo progresses from a simple hello world to fetching and displaying the top ten trending NFT collections by name, then expanding the view into a full table with floor price, volume, total sales, and average price data. Anthony deploys the finished app to Vercel, showing how quickly a developer can go from zero to a live NFT dashboard using the Icy Tools API.

00:18:00 - The React Hooks Package and Open Source Repo

Anthony shifts to the newly launched open-source React hooks package under QuickNode Labs. Dan describes it as a beta release that wraps popular Icy Tools queries into simple React hooks powered by Apollo, so developers can skip the GraphQL setup entirely and use one-liners like useTrendingCollections with customizable variables for sorting and pagination.

They explore the example app bundled in the mono repo, demonstrating the collections route and the wallet hook, which accepts either an Ethereum address or ENS name to display a user's NFTs. Dan looks up his own wallet to show the feature in action and previews upcoming portfolio queries. The segment closes with both encouraging the community to open issues, submit contributions, and provide feedback through Discord or Twitter.

00:26:52 - Wrap-Up and Community Call to Action

Dan shares the core mission behind the Icy Tools API and hooks package: reducing the pain of building in the NFT space by providing ready-made infrastructure so developers don't have to reinvent the wheel. He invites viewers to reach out on Discord or his Twitter handle with feature requests, bug reports, or ideas for new tools.

Anthony wraps up by noting that a step-by-step QuickNode guide based on the Remix demo will be published soon, and that the open-source repo and NPM package are available for experimentation and contributions. He thanks Dan for joining and expresses excitement about continuing to build out sample applications that showcase the full power of the Icy Tools GraphQL API.

Transcript

00:00:00 - Anthony Campolo

Hello everyone. Welcome back to Quick Streams. It's been a little while. We're really happy to be back and we have a super exciting guest here with us. Dan, how's it going?

00:00:38 - Dan from Icy.tools

Glad to be here.

00:00:40 - Anthony Campolo

Hey, why don't you introduce yourself for our viewers and let them know who you are and what you do.

00:00:47 - Dan from Icy.tools

Sure, yeah. I'm Dan. I'm a co-founder of Icy Tools, an NFT analytics platform. We were recently acquired by QuickNode, so we're all working on the same team now. My main focus is building APIs and developer tools right now, specifically in the NFT space, but probably going to expand that too.

00:01:12 - Anthony Campolo

Awesome. Yeah, I was super excited, actually, when our two companies came together because I'd been working at a GraphQL API company before I was working here at QuickNode. So I thought I was going to be kind of leaving the GraphQL world behind when I came here. But then all of a sudden we were like, hey, by the way, we just bought a company that has a GraphQL API. So that is pretty fun. And that's a little bit of what we'll be showing today. So what was kind of the decision to build a GraphQL API specifically? Because there are lots of ways to query data, lots of APIs you could expose, but you decided to build out a very specific kind of API. So what was the thinking behind that?

00:01:52 - Dan from Icy.tools

It's a good question. I think it's twofold. One is that I've kind of been building GraphQL APIs since you could kind of build GraphQL APIs. I'm not sure exactly when it came out, but I've probably been building GraphQL APIs for at least six or seven years.

00:02:10 - Anthony Campolo

Wow. Yeah. Long time.

00:02:13 - Dan from Icy.tools

Yeah. I think my co-founders at Icy Tools were all at the same company like five years ago. When I joined, GraphQL was kind of new, and I was like, hey, we should check this out. It's kind of cool. And we did.

00:02:26 - Anthony Campolo

Which company was that?

00:02:27 - Dan from Icy.tools

It was called Flip, renamed Caretaker. It's a real estate company helping people find apartments. And it was just an internal API. There wasn't necessarily a specific, like, oh, this is a slam dunk. GraphQL was mainly just like, hey, this seems better than REST. And then kind of over time, for all the projects I did, it kind of defaulted to GraphQL because I enjoyed the frontend experience of it a lot more. Like, if you use Apollo or Relay or whatever, all the free caching that you get is really incredible for building good, high-quality UIs and frontends very, very easily. And then with Icy, that was kind of half the decision, okay, we'll use GraphQL because that's what we like to use. But in addition to that, it just makes so much sense with web3 because the power of GraphQL is taking a large data set and being able to create all these connections between all the data that you have extremely easily. And I don't know, I can't really think of much of a better data set for that than blockchain data. So if we're talking EVM, we have contracts, we have tokens, we have logs, wallets, all these different objects that are all related to each other.

00:03:50 - Dan from Icy.tools

Wallets can have many logs. Logs can reference a wallet, they can reference a contract address, they can reference a token within the contract. All these things connect. And I think GraphQL really helps you unlock the true power of that. Well, it gives you a lot of power to query exactly the data that you want, right? Because I think in web3 things can get kind of specific, and especially with logs, you can really go into detail on what you want. So I think it's hard to model with, say, REST, the perfect API for every use case. You'd have to create so many different endpoints to cover so many different use cases. Whereas the flexibility GraphQL gives you is like, okay, I can do something crazy with some crazy filter on logs to only get mint logs and maybe some order logs as well that are filtered by this ENS address or whatever. You can go as deep as you want, and I think that's really cool and useful for developers.

00:04:49 - Anthony Campolo

Yeah, and it's so great hearing you make that pitch because when I was actually at StepZen right before I left, I was starting to make this pitch to the company and being like, hey, we should probably look at web3 and start getting into this. Because I found that despite how natural of a fit it is, most people in the GraphQL world don't really realize it or have any concept of what's happening in web3, or that they have this kind of perfect technology for it. And so I was starting to make this pitch, and then we had some other people on the team who were kind of getting into it. I actually did build out some web3 functionality with StepZen, but we had just started getting that going by the time I left the company. So now that I'm here at QuickNode, I'm kind of starting to explore the Icy GraphQL API specifically. And that's what we're going to be doing in the demo today, showing first how to connect to the API basically from any kind of frontend application.

00:05:45 - Anthony Campolo

We're going to use Remix specifically as our framework, and then we're going to show how to use this hooks package that you've created, which has some pre-baked React hooks that go along with these queries that we're doing. So if you want to give just a little bit of a description of that, and then we can talk about it a little bit more once we get to it, just give people an idea of what this hooks package is.

00:06:10 - Dan from Icy.tools

Cool. Yeah, I mean it's basically taking our most popular queries that people make. And this is brand new. We launched it into beta on Friday, so it's kind of new. We're going to add a lot more to it. But the idea is basically this: I just hyped up the flexibility of GraphQL. Obviously, the React hooks kind of take away a little bit of that flexibility. It's more opinionated, like, okay, a lot of people want to get the stats on a collection. What's the floor price of this collection? Or they want to get an image, a cached CDN resizable image. These are popular queries people make. So okay, we wrap them in a React hook. So instead of having to implement an API, you just install this package. It's a one-liner, like use NFT stats or whatever, use collection, grab the stats, throw it in your application. So it's a lot easier to get going than setting up, for example, the whole GraphQL environment. So GraphQL gives you more flexibility. Hooks are like, if the hook does what you want it to do, great, it's even easier to get going.

00:07:18 - Anthony Campolo

Cool. Yeah. And so that's kind of where I'll be showing a little bit of each. So if you want to build up your queries totally from scratch, you're welcome to do that. Or if you want to slot in some of these pre-made ones, then you can do that as well. So I'm going to go ahead and share my screen now and we will kick this off. A couple of things to show here. What we're going to be looking at is all at developers.icy.tools. Actually, the Icy Tools website itself is this built-out dashboard, which has some fun NFT names being displayed. We have an actual API that allows you to interact with the GraphQL API specifically. So we're not really going to be using the dashboard at all today. But this is kind of like the main Icy product, the dashboard, and the API is really more for developers. Is that kind of how you would describe the difference between the two?

00:08:28 - Dan from Icy.tools

Yeah, like the Icy Tools dashboard is kind of what we started with, and the API is exposing some of this data, hopefully most of it over time, to developers to help them make similar applications or different applications. Just opening up access to this data a bit easier.

00:08:46 - Anthony Campolo

Awesome. Yeah. And I know lots of people really love Icy Tools. Whenever I go out to like events, I always make sure to wear my Icy Tools T shirt because then people come up to me like, hey, I love Icy Tools. So you guys seem to have done a good job with what you built.

00:09:01 - Dan from Icy.tools

Thank you.

00:09:04 - Anthony Campolo

Once we are actually logged in, then we're going to have this little explorer here where we can run some queries. We also can go to this endpoint here, GraphQL Icy Tools Playground. Either of these will give us a way to query the data that we want to query. Are there any kind of big differences you see between the two? Like, is there kind of more functionality in the developers Icy Tools playground versus the regular kind of vanilla one?

00:09:41 - Dan from Icy.tools

There's no difference. The main difference with this embedded one is just that it automatically embeds your API key and stuff like that.

00:09:50 - Anthony Campolo

Yeah, so I've got that down here. I already included that. So yeah, that is a good callout here. You can just kind of get going and you're already going to be connected with your authentication. And then if you want to actually see your API key, you can click here on Settings, which I will not do. But then that will display your API key here, and then that's how we're going to connect to the GraphQL API. Because like with any GraphQL API, you basically have a header that you need to set with your key. And that header is going to be X-API-key, and then include your API key. If you want to just do a curl request, you could do that like so. Or if you want to do a fetch request from your framework of choice, which is what we'll be doing here. And that's all you have to include in the header to make the queries actually work.

00:10:41 - Dan from Icy.tools

I will say one other thing that the developer portal gives you on that playground there, that examples button on the top right. Oh yeah, you can go in there and there are a few kind of pre-made templates that are runnable. He really wants us to see those collection names right now. And yeah, you can get started with some popular different queries, and then you can obviously edit these, play around with them. It's kind of just helping people get started seeing what's possible.

00:11:10 - Anthony Campolo

Awesome. Very cool. Okay, now let's start creating our project here. So I'm going to go totally from scratch here and just show how to create a boilerplate Remix app. And we're going to create a couple files here. We're going to have a queries file for our queries, and then we're going to install the Vercel CLI, which will make it easy to deploy this quickly as well. We don't actually need any dependencies because in the way I did the example, we just do a fetch request. But once we show the hooks package, that's actually using Apollo, is that correct?

00:11:56 - Dan from Icy.tools

Yeah,

00:12:00 - Anthony Campolo

We're going to give it just a little bit of styling. This will be our query. It's our trending collections query, which will show us the top 10 trending collections. Have you ever used Remix before?

00:12:17 - Dan from Icy.tools

I have not. I'm excited to see what you come up with here.

00:12:20 - Anthony Campolo

Cool. Yeah, the cool thing about Remix is it's a React meta-framework and you can think of it a little bit like Next.js. It gives you a lot of the same type of opinions, in the sense that it has a router, it has all of your pages contained in specific folders, and then they have API routes and things like that. But the main thing that we'll be doing is using their loader function, which makes it really easy to run queries on the server side. That's really useful because we have an API key here, and normally when you're doing GraphQL stuff, people kind of stick their API key in their React client, which you really shouldn't do, right?

00:13:07 - Dan from Icy.tools

Yeah, that's a good thing to flag because it's something that is currently in the backlog of things to add to Icy. We'll probably try, I mean, this is a great way to handle it right now, but we also want to probably add some domain whitelisting so you can associate a domain with your website, sorry, with your API key, and then we can do that validation on the backend. So even if your public key is stolen, no one can use it.

00:13:41 - Anthony Campolo

Gotcha. Cool. Yeah. And so what we're doing here is I'm just giving us a little bit of styling here. This is like a Remix convention where you can just slot in a stylesheet like so. And then this will be our home route. Right now we just want it to say welcome to Icy Tools with Remix. And we can kick this off now to see what we got. And this is just our little hello-world Remix app. Right now, if we want to add something here, say hello, do that, we'll see the change over there. Now we're going to, I like to keep the queries separate in their own folder, but you could also have this inside this file as well. Set up your project structure however you want. This is hitting that GraphQL Icy Tools endpoint and then setting the API key here and then feeding in the query, which then is JSON-stringified in the body. So I'm going to hop off for a second so I can actually include that key here. And this is always the fun dance in the stream where you figure this part out.

00:15:18 - Anthony Campolo

Okay, good. Back to sharing. Then now we can actually output our query data. So this is the kind of Remix convention here. We're doing useLoaderData. And what this does is it runs this loader function and then it takes the results of that loader function and sets it to this data object. And then we map over that. And first I'll just display a list of the names of each of those contracts. Cool.

00:16:02 - Dan from Icy.tools

So you just have to have, like, a function named loader and it finds it.

00:16:06 - Anthony Campolo

Yep, exactly. And then there is our first 10. So if we want to display more of, oh, hey Rugrats and Hey Arnold, I loved Hey Arnold as a kid. If we want to map over these and display more of the data, then we can grab this whole thing. And what this is doing is now we're creating a table, and then we're going to get a couple more pieces of information like the floor price, the volume, total sales, and then the average price. So now this is a little bit more like an actual dashboard, and we get to see all of the sales information associated with this as well. And this is what a lot of people who are getting into NFTs and want to know what the popular NFTs are, this is basically what they do. They're just like, okay, what is trending right now? What is selling? What is kind of hot? And then they can go look at it and find out what they are. Any comments or things about what I've shown so far?

00:17:16 - Dan from Icy.tools

It looks pretty cool. Isn't it cool? You can just get all these stats so quickly.

00:17:22 - Anthony Campolo

Yeah, no, it's really, really great. And then if we want to deploy this, we do yarn Vercel, and then we can pass in the environment variable. I have actually already deployed this previously, so I will just go to Vercel. So once you deploy it, it'll look exactly like what we're looking at on localhost, but then actually on your Vercel URL. So now we've got kind of an actual dapp that is technically not decentralized since it's on Vercel, but it's pretty close.

00:17:59 - Dan from Icy.tools

Awesome.

00:18:00 - Anthony Campolo

Yeah, cool. Now let's take a look at your hooks package. That's if you wanted to build up your project from scratch with connecting to the API and writing your query and including your query in your framework of choice. In any framework where you can do GraphQL, you can do this. We're going to have examples for Nuxt and for Svelte and for a lot of these different things. But as you said, we also want to give really good opinionated hooks for these specific frameworks. So if you are a React dev, then we have some specific hooks for you here. These are going to be at QuickNode Labs and then qn-oss. This is something that you've been working on with the team, and right now you would say this is like beta, right? But it's pretty much ready for people to start testing out. Would you say you want people to open issues or contribute to it at all? Because this is an open source thing, like how open source is this?

00:19:08 - Dan from Icy.tools

Yeah, it's a good question. It's like we launched it, as I said, on Friday, I think. So it's kind of in beta. It should mostly work. There are some issues with certain webpack configs we're trying to work through, but in general it should work. It's on NPM. This is a mono repo, so there will be more SDKs to come in this space, more libraries. We'll add a lot more. I just realized that's actually not an up-to-date readme, but we'll add more. It's all good.

00:19:44 - Anthony Campolo

There's also, I realize, a bug here. You're missing a closing parenthesis here. So I'll do a PR for your readme. I noticed a couple things while setting this demo up.

00:19:54 - Dan from Icy.tools

Awesome. Yeah, so I mean, that's the thing. It's going to be open source, so like we're still working on like templates and stuff like that. But feel free to open issues, whether it be a bug or a query that you would like to see supported that we don't support yet, it's usually just a matter of writing them. There's no reason why we can't have more on here. And yeah, we'll definitely welcome third party contributions to the repo as well.

00:20:22 - Anthony Campolo

Great. Awesome. Yeah, open source is kind of how I first got my start in the industry, so I think that's really cool. And I've been kind of pushing to get more stuff on GitHub and more example apps and more code samples that people can work with. So I was really, really excited to see that you had put this together. Okay, thank you. Yeah. So we're going to just clone this down and then cd into it. First you want to install your packages, and then there is an example app built into the package. This is a really nice touch, that if you want to start seeing these and see how they work, you can do that. And the only thing you have to do is set up an environment variable. You have packages, apps, examples, and then .env.local.example. I'm going to copy that over into an actual .env.local file and then do the environment variable dance one more time. Then once we have done that, we'll be able to run this example app. Cool. And this will start here.

00:21:53 - Anthony Campolo

And then you want to run this build command to build everything and then this yarn serve command. These are commands you can find in the readme of the package itself. Then that will open us up on localhost:4200. Here's our current thing. Right now we don't see anything. We have to go to one of our routes, and we can check out the collections route. This is basically the same data we were seeing before. I had built something from scratch earlier that's fairly similar to the examples you had already built, so that's why this looks very, very similar. Then we also have this wallet here. So if we wanted to see what NFTs Vitalik has, then we can see that here.

00:22:46 - Dan from Icy.tools

Not the best mobile styling.

00:22:50 - Anthony Campolo

Yeah. Right, yeah. CSS. It's always the hardest, isn't it?

00:22:54 - Dan from Icy.tools

How about we quickly try this? Could you hop into this, like, it should be called collections GraphQL or GQL in the, oh, sorry, in the hook itself. So what you can do is change the order by to volume.

00:23:11 - Anthony Campolo

Cool. Where am I going?

00:23:13 - Dan from Icy.tools

Line nine. Right there. Change that to. I think it should be exposed via typescript, but change it to volume.

00:23:21 - Anthony Campolo

So order by volume. Like that.

00:23:23 - Dan from Icy.tools

Yeah. And now if we refresh that, we might get rid of that horrible name.

00:23:27 - Anthony Campolo

Nice. Very cool.

00:23:30 - Dan from Icy.tools

Yeah. So like you're. You're able to order by volume, the default number of sales, and then the other one is average, I believe.

00:23:40 - Anthony Campolo

Okay, so what's happening here is we have this huge trending collections hook, and this is as long as we feed in these, which are basically GraphQL query variables, right?

00:23:53 - Dan from Icy.tools

Yes.

00:23:54 - Anthony Campolo

Yeah. And so is the GraphQL query, like, actually exposed here if we want to go in and mess with that? Or is the idea that you want to hide that away behind the use trending collections?

00:24:05 - Dan from Icy.tools

Yeah, it's in the, so, like, we're currently consuming this example app, which is in turn using this NFT React Hooks package. So the NFT React Hooks package is something you just install into whatever your app is. And obviously you could go into node_modules and change the query if you wanted to, but obviously not the best idea. The idea is.

00:24:29 - Anthony Campolo

So that's where the query is. It's in the actual NPM package itself that you're then installing. So the queries are there, but they're in your node modules.

00:24:38 - Dan from Icy.tools

Exactly. So the idea is that we're just abstracting that away and then exposing some variables in which to sort by or filter by. You can change the time period.

00:24:54 - Anthony Campolo

You've also given us some pagination here, which is very nice. So if we want to scroll through, we can do that. And let's look at the wallet hook. So what's happening here? We're basically taking in the ENS name and then displaying basically their tokens, right?

00:25:21 - Dan from Icy.tools

Yeah. So you can either pass in a wallet address or an ENS name and it'll return a few things, like just the NFTs that they own and then also, like, is search valid? So if you're trying to type in an ENS name, does it match the regex of that? If you're typing in an Ethereum address, does it match the regex of that?

00:25:44 - Anthony Campolo

Cool. Do you have a wallet with some NFTs in it?

00:25:48 - Dan from Icy.tools

Sure. You can do Danzabar. D A N, Z I B A, R. Sorry, I spelled bar from there. Eth.

00:26:00 - Anthony Campolo

Nice.

00:26:00 - Dan from Icy.tools

[unclear].

00:26:01 - Anthony Campolo

All right, you got a donut. Okay, we can be friends.

00:26:04 - Dan from Icy.tools

All right, that's a QuickNode thing. Everyone needs donuts. Soon we're going to expose a portfolio query so you can actually get more than just NFTs. We'll expose the value of your NFTs, the value of your portfolio, and how much, if you have diamond hands or paper hands. I definitely have paper hands, [unclear], and basically all of these. Not the best NFT collection, but yeah, it's fun.

00:26:31 - Anthony Campolo

Got the IC Founders Club.

00:26:33 - Dan from Icy.tools

That's a good one. That's the only one I've made money on just because I got it for free.

00:26:39 - Anthony Campolo

Great. Awesome. So that's pretty much the main things that I wanted to demo here. So are there any kind of final calls to action or things you want people to check out before we close it out here?

00:26:52 - Dan from Icy.tools

No. I mean, honestly, our goal and mission is to help people build in the space more easily. Like when we built Icy Tools, it was a pain. There wasn't much infrastructure out there. We had to do basically pretty much everything ourselves. So what I'm trying to do is make it easier for the next person to build something cool without having to worry about reinventing the wheel. So on that note, super appreciate feedback. You can hop into our Discord or my Twitter, Daniel jvdm, with feature requests, bugs, whatever. If there's something cool that you think needs to be built, let's talk about it.

00:27:33 - Anthony Campolo

What was your Twitter handle?

00:27:36 - Dan from Icy.tools

Daniel jvdm.

00:27:45 - Anthony Campolo

Cool. Yeah, I'm dropping these in the chat for anyone hanging out, and then we will be uploading this video to YouTube as well. So we'll have some information in the description as well. And what we built out with the Remix app today, that's going to be an official QuickNode guide. In the next week or two we'll be getting that published. So if you want to walk through what we did here step by step, then we'll have a nice built-out guide for you as well. And then we have the open-source repo that we showed, and an NPM package if you want to play around with that. So we definitely welcome contributors, or if you have any weird bugs or you run into anything that you don't quite understand, feel free to let us know. And yeah, this is really cool stuff. Dan, thank you so much for being here. I'm super excited to get to work with all this cool GraphQL, NFT stuff. I'm looking forward to getting more of these sample apps and more of these guides created so people can really harness the full power of the Icy Tools API.

00:28:43 - Dan from Icy.tools

Cool. Thanks, Anthony. Thanks for having me on.

00:28:45 - Anthony Campolo

Yeah, no problem. Thank you, everyone. Have a good day.