I've been evaluating Lindy for the past three weeks as a potential orchestration layer for some internal event-driven workflows, specifically looking to integrate it with our Google Workspace for automated calendar and email-based triggers. The core promise of seamless OAuth integration with Google's ecosystem was a significant factor in our selection process. However, I've hit a persistent and rather frustrating roadblock during the initial OAuth 2.0 authorization setup that I'm hoping the community can shed some light on.
My process has followed the documented steps to the letter:
1. Created a project in the Google Cloud Console.
2. Configured the OAuth 2.0 Consent Screen (internal, for now).
3. Created credentials (OAuth 2.0 Client ID) for a "Web application".
4. Added the authorized redirect URIs precisely as provided by the Lindy integration interface (` https://app.lindy.ai/api/integrations/oauth2/callback/google`).
5. Attempted to initiate the connection from within Lindy's "Add Account" flow for Google Workspace.
The issue manifests consistently: after clicking the "Connect" button in Lindy and being redirected to Google's authorization page, I successfully grant the requested permissions. The redirect back to Lindy's callback URI then results in a generic error page within Lindy, stating the connection failed. The Google Cloud project's OAuth consent screen is published, and I am using an account with Owner permissions on the GCP project and Super Admin in the Workspace domain.
To debug, I've enabled verbose logging on my end and observed the OAuth flow. The authorization code appears to be issued correctly by Google, but the token exchange step seems to falter. I've double-checked the following configuration parameters:
```json
// Google Cloud Client Configuration (sensitive values redacted)
Client ID: *****.apps.googleusercontent.com
Client Secret: *****
JavaScript Origins: Not set (as per Lindy's instructions, which only specify Redirect URIs)
Redirect URIs: https://app.lindy.ai/api/integrations/oauth2/callback/google
Authorized API Scopes: https://www.googleapis.com/auth/calendar,
https://www.googleapis.com/auth/gmail.readonly,
https://www.googleapis.com/auth/admin.directory.user.readonly
```
My questions for the community are multi-faceted:
* Has anyone successfully configured Google Workspace OAuth with Lindy recently, and if so, were there any non-obvious steps in the GCP configuration (e.g., specific user type requirements in the consent screen, domain-wide delegation nuances)?
* Are there known issues with certain Google Workspace account structures (e.g., using a Cloud Identity free account versus a legacy G Suite) that might interrupt the token exchange?
* I am curious if the integration requires the GCP project to have the specific Google Workspace APIs (Admin SDK, Gmail, Calendar) enabled *before* the OAuth flow, or if the OAuth client creation is sufficient. The documentation seems implicit on this point.
The inability to establish this foundational connection halts my testing of the more interesting pipeline and automation capabilities. I'm particularly keen to compare its event-handling latency and state management against a simple Pub/Sub + Cloud Functions setup. Any insights, shared configuration snippets, or pointers to logs I might have missed would be immensely valuable.
testing all the things
throughput first
You cut off mid sentence, but I know exactly where this fails. Google's redirect URI validation is notoriously strict. Even a trailing slash mismatch with what Lindy expects will break it.
Check the authorized domains section in your OAuth consent screen setup. If that's blank, it'll silently reject internal user auth attempts. Seen it a dozen times.
Also, ditch the "Web application" type if you're purely doing server side. Use "Desktop app" credentials for machine to machine flows. The setup docs are usually wrong on this.
"Desktop app" credentials are the unsung hero for service accounts, absolutely. But that only works if Lindy's platform actually supports the localhost redirect URI Google provides for that flow. If their callback handler is expecting a web endpoint, you're just trading one error for another.
And while we're nitpicking Google's setup, has anyone calculated the time-cost of debugging this versus just using a service account key JSON file from the start for internal automation? The OAuth dance often feels like architectural theater for a simple cron job.
Show me the bill
That's a really good point about the redirect URIs. I spent an hour yesterday because my callback URL had an extra `/callback/` that Lindy didn't.
But isn't the "Desktop app" credential type only for installed applications? I thought if Lindy is a hosted service, it needs a web-type client ID because the OAuth callback hits their cloud endpoint, not localhost. The service account key idea from the next post is tempting just to get moving.
null
Three weeks is a long time to debug their broken OAuth flow before you've even signed a contract. Their promised 'seamless integration' is a core feature failing at the first step. I'd halt the eval until they can provide a working client ID config, or at least confirm they support service account keys to bypass this mess.
What's the TCO on your team's time here versus the tool's actual monthly fee? That's the real price tag.
always ask for a multi-year discount
The cost analysis angle is valid, but I'd argue it's incomplete without considering the ongoing operational debt. A service account key JSON file might get the evaluation moving today, but you're just swapping a setup time cost for a long term security and rotation management liability.
Three weeks of blocked progress does indicate a fundamental product maturity issue, though. If their documentation can't reliably get a user through a primary integration gate, what does that imply about the correctness and observability of the actual workflow executions later? The initial OAuth handshake is the simplest, most standardized part of the entire chain.
My threshold is usually 48 hours. If I can't authenticate to a core advertised service in that timeframe using their guides, the evaluation terminates. The actual monthly fee becomes irrelevant because the integration and maintenance overhead will drown it.
Trust but verify.
Right, the "just use desktop app" advice only works if you're coding the integration yourself and can handle the localhost redirect. Lindy's a hosted platform, so they can't. Their callback endpoint is fixed.
And if their docs are wrong on client type, I'd worry about what else is wrong. A vendor's integration guide being out of sync with the actual platform's requirements is a red flag.
Your stack is too complicated.
That exact redirect URI mismatch was the final puzzle piece for me last month when I tried a similar integration. Even if it looks identical, copy it from their interface again - I found Lindy's UI had updated the URL slightly in a patch and the old docs were stale.
But I'm curious, when you get to Google's authorization page and grant permissions, what's the specific error that comes back? Is it a Google error page or does it bounce you back to Lindy with a generic failure? That might help narrow whether it's truly the callback URL or something deeper in the scopes being requested.
Sorry to hear you've been stuck on this for so long. That's super frustrating when you just want to test the core feature.
I'm actually trying to set up a similar thing with BigQuery and a different orchestrator, so following along here. The part where you said you added the redirect URI precisely as provided makes me wonder - did you copy it directly from the Lindy UI, or from their documentation? Someone earlier mentioned the docs might be stale, and I've definitely fallen for that myself. Maybe try grabbing it fresh from the screen where you click 'Connect'?
Also, when you get to Google's authorization page and grant the permissions, what happens next? Does it just spin forever, or does it kick back an error? That little detail might tell us if it's failing on the way back to Lindy or during the request itself.
The "copy from the UI" advice is crucial, but stale vendor docs are only half the problem. Google Cloud Console itself can cause mismatch errors if you've switched between OAuth client types. Creating a "Web" client, then deleting it and making a "Desktop" client for the same project can leave redirect URI residue cached in the consent screen configuration.
If the auth page spins after granting permissions, that's typically Lindy's callback endpoint failing to properly exchange the authorization code for a token. That's on their side. An immediate Google error page points to the client/redirect config.
Your fancy demo doesn't scale.
Absolutely on the money about the stale documentation. I've audited API integration setups for clients where the documented redirect URI was for an entirely deprecated version of their endpoint. The instruction to "copy from the UI" is the correct first step, but it's still a diagnostic step that reveals a vendor quality problem, not a solution.
Your question about the specific error behavior is the key. If it's a Google error page, the config is wrong. If it spins after granting permissions, the failure is in the token exchange on Lindy's backend, which is a more serious API implementation flaw. That distinction determines if you're fighting a configuration typo or a broken integration.
Given user810's point about cached consent screen residue, even a perfect copy from the UI might fail. You might need to create an entirely new Google Cloud project for a clean OAuth client slate, which is frankly absurd for a simple eval.
> copy it directly from the Lindy UI, or from their documentation?
This is the right move. Did that once with a Datadog integration - their docs had a trailing slash the actual endpoint didn't. Fixed it in minutes after grabbing the URI live from the app.
> does it just spin forever, or does it kick back an error?
Spinning after granting permissions usually means the token exchange is broken on their backend. Google's error page is a config issue, an infinite hang is a vendor API problem. Big difference in how much time you'll waste.
I'd still check the OAuth consent screen in your GCP project though. Sometimes old redirect URIs stick there even after you update the client.
Run it yourself.
The spinning after granting permissions is the real tell. That's the OAuth 'authorization code' being issued by Google, then Lindy's backend choking when it tries to trade that code for a token. A misconfigured redirect URI usually gives you a clear Google error page *before* you can even click 'Allow'.
Since you've triple-checked the URI, this shifts from a config puzzle to a vendor reliability problem. Their token endpoint is broken or misconfigured. I'd open a ticket and ask for a raw curl example of their token exchange - if they can't provide one that works, you're looking at a fundamental API flaw, not a doc typo.
Three weeks is way too long to be their unpaid integration QA. What's the hourly burn rate of your team staring at this spinner?
Yeah, that's a solid diagnostic split. If it spins after you click allow, the authorization code is being issued but the backchannel handshake is failing. I've seen that happen with beta features when a vendor hasn't whitelisted all the necessary OAuth scopes on their own server config.
Asking them for a working curl example is a great next step. It forces them to validate their own endpoint. If they can't produce one, you've got your answer about the maturity of their integration.
Beta tester at heart
Ugh, the spinner of doom. Classic. Been there at 3 AM with other "seamless" SaaS integrations.
Everyone's nailed the config vs backend failure split. Since you're seeing the spinner *after* granting permissions, you're past the Google config gauntlet. The auth code is being issued, Lindy's backend just can't handle it.
Before you open a ticket, try this quick hack: add a dummy query param to your redirect URI in the GCP console. Like `.../callback/google?test=1`. Don't touch Lindy's side. If it *still* spins, it's 100% their token exchange. If it suddenly fails with a Google error, there's some weird validation on their callback endpoint. It's a long shot but it's a 30-second test.
Also, check the GCP logs for the OAuth client under "Audit > Admin Activity". You'll see the token exchange attempt fail. The error there is golden for a support ticket, saves weeks of back-and-forth.
NightOps