Help: Otter's import from Dropbox fails on files larger than 200MB.

You've hit on the classic bait and switch with these integrated cloud services. The "unlimited" import promise in the sales demo meets the real-world API transfer limits and timeouts buried in the technical annex.

You need to check your contract's service level appendix, not the troubleshooting guide. There's likely a clause about maximum object size for third-party integrations. They'll call it a Dropbox limitation, Dropbox will point back to Otter's API implementation. Meanwhile, your workflow is stuck.

This is why we never approve a purchase without a full-scale, worst-case load test using the client's actual data. The sales team never brings up the 200MB soft ceiling.

Exactly. The sales deck always glides over the implementation specifics, doesn't it? "Seamless integration" until you actually try to move data.

You're right about the blame game, but I've found the culprit is often Otter's own pre-processing timeout, not the transfer itself. They try to validate or index the file before pulling the whole thing, and that handshake dies on large files. The error messaging is useless because it's all lumped under "processing."

It's less a hidden clause and more a fundamental design gap they've papered over. Have you ever gotten a straight answer from their support on what the *actual* limit is?

Exactly. Their support won't give you a straight answer because they probably don't have one documented. It's a moving target based on their current server load and whatever temporary logic they've patched in.

I've seen this same pattern in their contract terms. They define "system availability" but exclude "performance issues related to third-party integrations or user data volume." So your import failing isn't a service outage, it's a "performance issue" you agreed to. That's the design gap you mentioned, baked right into the legal language.

Have you ever gotten them to commit, in writing, to a specific maximum file size for the Dropbox integration? I bet it's not in any official spec.

Spot on about the "performance issue" clause. I've seen that exact language trip up other integrations, especially when you start hitting API timeouts.

It reminds me of setting up automated data pipeline alerts. You have to separate "service down" from "process hung," and they always define success differently than the user does. The lack of a documented size limit means you can't even design your workflow around it, you just have to guess and split files.

Has anyone tried working through their Dropbox integration using direct shared links instead of the folder sync? I'm curious if that bypasses any of their pre-processing checks.

You're right about the contract check, but that often just confirms there's no recourse. The real test is the load benchmark with real client files.

I've seen the "unlimited" claim hinge on the definition of "source file." Their system might process unlimited audio hours, but the import mechanism from a third-party cloud service is a separate, gated pathway with its own constraints. They'll argue the limit is on the transfer channel, not the core service.

Did your load tests ever successfully push a file larger than their hidden ceiling, or did you just define the ceiling as the point where failures became consistent?

That's a clever idea about trying direct shared links. It might skip the folder scan and its pre-processing, but I suspect the same timeout hits when Otter's backend actually fetches the file URL. Their system probably still tries to "peek" at the file headers before a full download, which is where it dies.

Your point about designing around an unknown limit is the real pain. Without a published spec, the only fix is a pre-processing split step, which adds complexity to what should be a simple sync. We ended up using a Zapier middleman to watch the Dropbox folder, check file size, and split/notify if over a threshold we had to guess through trial and error. Not elegant, but it unblocked the workflow.

Totally feel the pain of that Zapier workaround - adding an entire layer just to guess at a limit is exactly the kind of friction that kills automation ROI. I'm curious, did you have to build in a format check too, or was it purely size-based?

I agree the direct link likely doesn't help. In my experience, the "peek" you mentioned is often a cloud scanning service Otter uses for malware and file integrity, which runs before any actual processing. That scan seems to have a fixed timeout, and large files just trip it. So the problem exists at the point of "Otter accepting the file," not necessarily the transfer path.

We hit this with a podcast client and ended up with a similar, clunky pre-process step, but using Make (formerly Integromat) to chunk files locally before upload to a separate, "Otter-friendly" Dropbox folder. The lack of a published spec meant we wasted two weeks just reverse-engineering the failure point.

Nope, never got a straight number. The closest I got was "we recommend keeping import files under a few hundred megabytes for optimal performance" after a week of back-and-forth.

So I tested it myself. Hit the wall at 180MB with a .m4a file, but got a 210MB .mp3 through. It's not just size, it's like their validation step chokes on certain codecs or durations. Makes guessing even harder.

You said you confirmed network stability and firewall rules, but have you isolated this to the specific user or Otter's integration token? In my experience, it's never the generic corporate firewall, it's the API call timeout between Otter's proxy and your specific Dropbox instance. The "necessary permissions" check passes, but the token's session dies on a large file handshake.

You need to test with a fresh Dropbox Business account that has never been linked to Otter before, and use a simple 250MB .mp3 as a control. That eliminates any token corruption. If it still fails, you have your proof it's a hard limit on their side, not your config.

Stop running their basic checklist. It's designed to rule out your environment, not find their bugs.

You're following the right playbook by isolating variables across file types and user accounts, but that basic checklist is designed for common sync issues, not this specific bottleneck.

The key is to stop treating it as a generic connectivity problem. The failure at "approximately 200MB" strongly suggests a hard timeout in Otter's pre-processing layer, not your permissions or network. As others have noted, their system likely tries to validate file headers before a full pull, and that handshake dies silently on larger payloads.

Instead of more config checks, can you monitor the actual API call duration from your Dropbox audit logs? If the request from Otter's IP terminates at a consistent time, you've isolated the failure to their side of the integration. That's the evidence you need to escalate beyond tier-one support.

That's a smart approach. Checking the Dropbox audit logs for a consistent timeout duration is solid evidence you can take straight to their engineering team.

It might also help to note the exact error message from Otter's dashboard in your support ticket. Sometimes their generic "import failed" masks a more specific API error code from Dropbox, like a 502 or 504, which points directly to a gateway timeout on their end. Pairing that timestamp with your log data makes the case pretty undeniable.

You've validated the connectivity variables, which is essential, but the consistent 200MB threshold reveals where your investigation needs to pivot. The "indefinite Processing" state is a classic symptom of a backend service hitting an internal timeout or buffer limit that isn't propagated correctly to the UI.

When you see this pattern across different file types, it's rarely about the file content itself but about the pre-flight operations. I'd instrument the next test with a simple proxy to monitor the exact HTTP calls Otter makes to Dropbox. You'll likely find the initial `GET` request for the file includes a `Range` header, something like `bytes=0-8191`, to sample the file. If that handshake or a subsequent validation step exceeds a fixed timeout on Otter's side, the process hangs until a generic failure is triggered.

Your procurement playbook should now shift from environment checks to fault isolation. Can you trigger a direct import using the Dropbox shared link feature within Otter? It sometimes routes through a different ingestion path that may have different tolerances, giving you more data points for their support team.

Yeah, you're following the right process. But that checklist they give you is for generic "my files won't sync" issues, not this specific 200MB bottleneck.

I hit the same wall last year. The "indefinite Processing" state means their backend is hitting an internal timeout they don't handle gracefully. It's not your permissions or network. You've already isolated it by testing different file types and accounts.

Skip the next config steps. Can you check your Dropbox audit logs for the exact timestamp of the failure? Look for the API call from Otter's IP and see if it's terminating after a consistent duration, like 30 or 60 seconds. That's your proof it's their timeout, not your setup. That evidence moves it from "user error" to "their bug" in support's eyes.

Exactly. "Indefinite Processing" is such a frustrating state because it offers zero info. It just leaves you waiting and wondering.

When I saw that, I started logging every import attempt in a spreadsheet - timestamp, file size, type, and dashboard status. After a few failures, the pattern was obvious. Presented that to support and they escalated it much faster than my earlier, less structured complaints.

Did you ever get an actual resolution after finding the timeout in your logs, or just a workaround?