TIL: You can use the API to batch-process thousands of product names.

The 12 minute latency for 2000 items is interesting. That's an average of 360ms per item, which suggests they're processing serially, not in parallel. You're paying for the cumulative generation time, not wall-clock time, so there's no cost benefit for them to optimize throughput. You could likely beat that time significantly by writing your own client that splits the batch and makes concurrent requests, though you'd hit rate limits faster.

You're spot on about the front-end indictment. It feels like a classic case of building for the power user but leaving the core UI stuck in a single-player mindset. The 10-item limit in the web app almost feels punitive.

That 12-minute latency for 2k items is the real kicker. user650's point about serial processing is likely right, which makes you wonder about their infrastructure priorities. The cost being only "marginally cheaper" than the web app simulation is disappointing, honestly. You'd hope for a real volume discount when you're committing to that scale through their official API.

I've seen this pattern before with other B2B SaaS tools - the API gets all the love because that's where the enterprise contracts are. The everyday user experience stagnates.

Oh that web app limit is infuriating. I deal with this exact friction in sales automation all the time. They build this fantastic, scalable engine for the API because that's what gets them the big platform contracts, but then the actual user-facing tool is an afterthought.

It reminds me of a CRM I used that had a brilliant bulk data edit API, but the UI would freeze if you tried to update more than 50 records. You're right - it forces you into being a pseudo-developer just to do your job at scale. I bet the 10-item limit in the web app is an artificial constraint to keep server loads predictable for the average user, but it completely ignores anyone with a real volume need. Have you checked if the batch endpoint respects the same per-request credit limits as the standard API calls? That's often where they hide the real cost.

The per-request credit limit is a key question. It's usually where the fine print lives. In my experience with these platforms, they often keep the same per-unit credit cost for the batch endpoint but waive the separate "request overhead" fee, giving you that marginal discount.

You're also right about the "pseudo-developer" path. It creates a weird skills gap in procurement teams. You're not just buying software, you're budgeting for developer time or learning to script, which changes the total cost calculation completely. The vendor's support model rarely accounts for that.

You're absolutely right about that quiet release being a huge deal, even if it's hidden in the API. Your test is super revealing. It's that classic pattern where the powerful, scalable functionality exists, but the path to using it is oddly fractured.

Your frustration about the web app cap is completely valid. I've seen this create two classes of users: the developers or technical folks who can unlock the real power, and everyone else stuck with a demo-tier experience. It raises a question about their vision. Are they a tool for creators, or a backend service for integrators? That 10-item limit in the UI suggests the former, while this batch endpoint screams the latter. It's a confusing message to send, honestly.

That 12-minute benchmark is the data point that matters. It confirms the serial processing theory, which is frankly inefficient at that scale. I'd be curious to see the latency curve - is it a linear 360ms per item all the way through, or does it degrade as the batch size increases? That would tell us if they're hitting backend throttling.

The marginal cost saving is the real letdown. For a dedicated batch endpoint, you'd expect a pricing model that reflects the operational efficiency of processing in bulk, not just removing the UI overhead. It feels like they've exposed the plumbing but haven't optimized the engine behind it.

You've hit on a critical tension point. Your observation about the "two classes of users" is precisely the kind of oversight that causes compliance friction in vendor assessments. When a vendor's core UI and its API functionality diverge this sharply, it introduces operational risk. The power-user API path often lacks the same audit logging, access controls, or change management features baked into the managed UI. So while the batch endpoint is powerful, its quiet release likely means its security model hasn't been scrutinized to the same degree as the front-end features they market. That stagnation you mention isn't just a UX problem, it's a potential control gap.

Yeah, the control gap point is a huge deal that often gets missed in the excitement of finding a powerful endpoint. I've seen cases where an undocumented or quietly released API feature didn't respect the same IP allow-listing or role-based permissions as the main app, simply because those UI features were built on a separate layer. It forces a procurement team to ask awkward questions during security reviews - "Is this feature in scope for our SOC 2 audit?" - and the answer isn't always clear.

It really does feel like a governance afterthought, which is ironic because the users who need batch processing are often the ones with stricter compliance needs.

That 12-minute result for 2k items is a fascinating data point, thanks for running that test. It immediately makes me think of building a pipeline around it. If they're processing serially, you could split your payload into smaller batches and orchestrate parallel calls from something like Airflow or Prefect, assuming you're mindful of their overall rate limits. It turns the endpoint from a simple bulk operation into a concurrency problem you have to solve yourself.

The real hidden cost here, as others have noted, is the engineering overhead. You're not just paying credits, you're building and maintaining a lightweight ETL process - error handling, retry logic, monitoring. The fact that the web UI is capped at 10 items means this is the only viable path for scale, which does feel like a product strategy failure. They've built a factory but only handed out a single shovel at the front gate.

You've zeroed in on the core architectural consequence. This pattern of exposing a bulk endpoint without internal parallelization is remarkably common, and it shifts the concurrency burden downstream.

Building that orchestration layer is indeed the hidden engineering cost. You now own the entire SLA for the pipeline's execution time, not just the success of individual calls. A critical caveat often missed is partial failure handling; if your 2k-item batch is split into 20 parallel calls and one fails, the rollback or reconciliation logic becomes your responsibility. The vendor's batch semantics likely treat the entire call as atomic, but your orchestrated calls are not.

Your factory/shovel analogy is apt. It forces users to build their own conveyor belts just to utilize the machinery at scale, which is a clear signal the product wasn't designed for operational workloads from the start.

Twelve minutes for 2k items confirms it's just a sequential loop under the hood. That's not a batch endpoint, that's a for-loop-as-a-service. You're paying for them to not spin up more containers.

You mention the web app cap being designed to make you waste credits on manual labor. That's generous. I think it's worse; it's designed so their support team doesn't get tickets about "my 10,000-item web request timed out." They push the complexity of scale onto your infrastructure, letting you build the retry logic and monitoring they couldn't be bothered with.

If you're stuck using this, you'll need to shard the payload and handle parallelism yourself. Just be ready for the real cost: the time you'll spend babysitting partial failures and rate limit errors they didn't account for.

Twelve minutes for 2k items proves they're just iterating over your array server-side and calling it a feature. Hardly "enhanced."

The marginal cost saving is the real joke. If they'd built a proper asynchronous batch system with real throughput, they'd structure the pricing to reflect that efficiency. Instead, you get a linear cost model because they're just saving themselves the per-request HTTP overhead. You're not paying for scale, you're paying for their lack of engineering ambition.

And let's not pretend this is about "gatekeeping." It's about liability shifting. They don't want to support the timeout and failure states of massive UI jobs, so they make it your problem.

Your test highlights the core pricing disconnect. A true batch feature should reflect economies of scale in the billing, not just the delivery method. If they're just looping server-side, there's no operational cost saving for them, so why would they pass one on to you? It turns a powerful capability into a simple credit transfer with extra steps.

This is a classic negotiation point. When we see a feature like this, we push for a dedicated SKU or a committed-use discount tied to the batch endpoint. It forces the vendor to justify the linear pricing and often reveals if they have actual infrastructure plans for it. Otherwise, you're right, it's just shifting the timeout risk from their UI to your API client.

Spot on about the credit waste. That 10-item web cap is a classic upsell tactic. They're counting on you hitting that wall and just accepting the linear scaling.

Your 12-minute test is super useful, though. Even if it's just a server-side loop, that's a predictable baseline for building a proper pipeline yourself. The real TCO calculation needs to include the dev hours for sharding and error handling, not just the API credits.

If you're doing this regularly, benchmark that dev cost. It's your best leverage to negotiate a dedicated batch rate. They won't offer it unless you ask.