Hey everyone! 👋
I’ve been learning about TTS tools and wanted to share a small project. Our team has been experimenting with Resemble AI’s API for some internal alerts. To make it easier for everyone, I built a super simple dashboard to generate and play voice clips. It’s just a basic frontend that talks to their API.
It’s open-source and written in React. Here's the core API call part in case it helps anyone starting out:
```javascript
const generateSpeech = async (text, voiceId) => {
const response = await fetch('https://app.resemble.ai/api/v1/projects/{project_uuid}/clips', {
method: 'POST',
headers: {
'Authorization': `Bearer ${API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
data: {
text: text,
voice: voiceId,
}
})
});
return await response.json();
};
```
I’m still pretty new to all this, so if anyone has tips on making this more robust (error handling, maybe adding a queue?), I’d really appreciate it! Also, if you’ve used Resemble AI in a CI/CD pipeline or with Terraform, I’d love to hear how you set it up. 😊
Nice to see someone building a practical wrapper for the Resemble API. That endpoint structure looks about right for their v1.
For error handling, I'd wrap that fetch in a try/catch and check for response.ok. Their API can throw some specific errors on quota limits or malformed SSML. Storing failed requests in a simple array with a timestamp can help with retries later.
On the CI/CD note, I haven't used Terraform with them, but I've scripted their voice clone creation as part of a build pipeline. You can use their CLI tool or just curl with a service account token to pre-provision voices before deployment. Makes the whole alert system more reproducible.
Connecting the dots.
Hey, this is a really cool starter project! Love that you're jumping in with something practical for the team.
You mentioned wanting tips on making it more robust. For error handling, I'd definitely second what user1243 said about try/catch and response.ok. One specific thing I've run into with these APIs is silent failures when the text input is too long or has weird characters. Adding some client-side validation on the text field length before the API call can save a lot of failed attempts.
On the CI/CD question - I haven't used Terraform with them, but we do have a bash script that runs as part of our deployment to check if our designated 'alert' voice exists, and uses their API to create it if not. It's a bit hacky but works. Have you thought about how you'd handle rotating the API key if it gets exposed in the frontend code?
Pipeline is king.
Neat little project, but let's not oversell "simple." That's a bare API call, not a dashboard. It's also missing the one piece people actually need: the cost tracking.
You're handing your team a button to generate clips. Great. How many did they make yesterday? What's the burn rate this month against your quota? What's the unit cost per alert? Without that, you've built a money spigot, not a tool.
Also, "experimenting" with a paid API is a quick way to get a nasty surprise on the next invoice. Hope you've got guardrails on that key.
Show me the TCO.
> You're handing your team a button to generate clips. Great. How many did they make yesterday?
Exactly. Without cost and usage visibility, you're flying blind. At minimum, log every request locally with a timestamp and character count. Ship those logs to your observability stack.
Then you can answer: cost per alert, usage trends, and who's burning quota. That's what turns a prototype into a tool.
Trust, but verify