Sentiment analysis sounds like one of those “easy” AI features.
You send text to an API. It says positive, negative, or neutral. Boom. Your app now understands feelings.
Cute idea.
Then real customer data shows up.
Someone writes, “Great, another update that broke everything.” That is negative, wrapped in fake politeness. Someone says, “The product is fine, but support made me want to scream into a pillow.” Mixed sentiment. Someone writes one angry sentence inside a mostly positive review. Someone praises the delivery speed but complains about pricing. Someone uses slang, sarcasm, emojis, multilingual text, or a 900-word support rant with three different moods inside it.
So yes, sentiment analysis APIs are useful.
But the best one depends on what kind of “mood reading” your app actually needs.
In this guide, we’ll compare the best sentiment analysis APIs in 2026 and look at which tools can help your app spot praise, complaints, frustration, and customer mood swings before they turn into churn, bad reviews, or a support inbox fire.
What is sentiment analysis?
Sentiment analysis is an NLP technique that detects the emotional tone of text.
The basic version classifies text as:
positive
negative
neutral
Example:
“I love the new dashboard. It loads so much faster now.”
Output:
{
"sentiment": "positive",
"confidence": 0.97
}
That is the clean demo version.
In real products, you usually need more than one label.
A strong sentiment analysis API may return:
| Feature | Why it matters |
|---|---|
| Sentiment label | Positive, negative, neutral, or mixed |
| Confidence score | How sure the model is |
| Sentiment score | Numeric mood scale |
| Sentence-level sentiment | Finds mood shifts inside longer text |
| Aspect-based sentiment | Finds sentiment about specific things |
| Entity sentiment | Tells whether users like a product, person, feature, or brand |
| Emotion detection | Spots anger, joy, sadness, fear, frustration, etc. |
| Language detection | Helps with multilingual reviews |
| Batch processing | Handles large review/support datasets |
| Custom models | Adapts to your industry or vocabulary |
| Summaries | Turns sentiment signals into human-readable notes |
The difference matters.
A plain sentiment label can tell you:
This review is negative.
Aspect sentiment can tell you:
The customer likes the product quality but hates the delivery experience.
That second one is where sentiment analysis becomes actually useful.
Why use a sentiment analysis API?
You can build your own sentiment model.
You can also train classifiers, tune embeddings, run open-source models, and maintain the whole thing yourself.
Fun, if that is your main product.
For most teams, an API is faster.
Sentiment analysis APIs are useful when you need to analyze:
- Product reviews.
- Support tickets.
- Customer surveys.
- App store reviews.
- Social media comments.
- Sales call transcripts.
- Chatbot conversations.
- NPS responses.
- Marketplace messages.
- Brand mentions.
- Community posts.
- Internal employee feedback.
A good sentiment API helps your app answer questions like:
Are customers getting happier or angrier this month?
Which product feature gets the most complaints?
Which support conversations need urgent attention?
Are negative reviews mostly about pricing, shipping, bugs, or customer service?
That is the real value.
Not just “positive or negative.”
More like “what exactly is going wrong, where, and how bad is it?”
Why we can write this guide
We’ve spent around 6 years working with AI APIs, NLP workflows, text classification, document parsing, sentiment analysis, embeddings, and LLM-powered automation. We also checked current provider docs and product pages for this 2026 roundup.
The practical lesson is simple: sentiment analysis is only useful when it fits the workflow.
A basic label is fine for a lightweight dashboard. Aspect-level sentiment is better for product reviews. Entity sentiment helps with brand and market analysis. Real-time sentiment is useful for support and call center workflows. LLM-based sentiment can help when text is messy, nuanced, or needs explanation.
So, let’s compare the actual tools.
Quick picks: best sentiment analysis APIs in 2026
Here is the fast version before we get into the details.
| Need | API to try first |
|---|---|
| Best all-around cloud sentiment API | Google Cloud Natural Language |
| Best AWS-native sentiment API | Amazon Comprehend |
| Best Microsoft/Azure workflow | Azure AI Language |
| Best enterprise text analytics | IBM Watson Natural Language Understanding |
| Best multilingual and detailed polarity API | MeaningCloud |
| Best entity-heavy text analysis | TextRazor |
| Best unified multi-provider sentiment layer | Eden AI |
| Best simple plug-and-play API | APILayer Sentiment Analysis API |
| Best multilingual/social listening direction | Repustate |
| Best lightweight developer option | Twinword Sentiment Analysis API |
| Best post-processing and routing layer | LLMAPI |
Now the deeper breakdown.
1. Google Cloud Natural Language
Google Cloud Natural Language is a strong first stop if you want sentiment analysis from a major cloud provider.
The API supports sentiment analysis for unstructured text, and the Google Cloud Natural Language sentiment docs explain that it can return document-level and sentence-level sentiment. Google also exposes an analyzeSentiment method in the Cloud Natural Language REST API reference, which makes it straightforward to connect from backend apps.
The output usually includes two important ideas:
| Field | Meaning |
|---|---|
score | Overall sentiment direction |
magnitude | Emotional strength, regardless of positive or negative direction |
That second field is useful.
Because these two texts are not the same:
“It's okay.”
“I absolutely love the product, but the support experience was unbelievably frustrating.”
Both may have complicated sentiment, but the second one has a lot more emotional energy.
Why it is worth trying
Google Cloud Natural Language is good for teams that want a stable cloud NLP service with sentiment, entity sentiment, entity analysis, classification, and syntax features.
Good fits:
- Product review analysis.
- Support ticket dashboards.
- Content moderation prep.
- Brand mention tracking.
- Entity sentiment analysis.
- Google Cloud-based analytics.
- BigQuery or Cloud Storage workflows.
- Apps that already use Google Cloud.
What to watch
Google’s sentiment scoring is useful, but you still need your own rules around what counts as urgent.
For example, a mildly negative support ticket about billing may deserve faster routing than a very negative tweet from an anonymous account. The business context matters.
2. Amazon Comprehend
Amazon Comprehend is the obvious pick if your product already lives in AWS.
The Amazon Comprehend sentiment docs describe sentiment detection for UTF-8 text documents and list API operations for detecting sentiment in one document or batches. Amazon Comprehend also supports targeted sentiment, and the Amazon Comprehend API reference includes operations such as BatchDetectTargetedSentiment.
That matters because regular sentiment tells you the mood of the text.
Targeted sentiment tells you the mood around specific mentions.
Example:
“The app is great, but the billing page is a nightmare.”
Plain sentiment:
{
"sentiment": "mixed"
}
Targeted sentiment:
{
"app": "positive",
"billing page": "negative"
}
That is way more useful for product teams.
Why it is worth trying
Amazon Comprehend is strong when your data already lives in AWS, especially in S3, Lambda, Kinesis, Glue, Redshift, or other AWS services.
Good fits:
- AWS-native apps.
- Product review analysis.
- Large batch text processing.
- Targeted sentiment workflows.
- Customer feedback analytics.
- Support ticket classification.
- Social listening pipelines.
- Data lake workflows.
What to watch
Amazon Comprehend can be very convenient inside AWS, but pricing and architecture depend on text volume, batch strategy, and surrounding services. Check the current Amazon Comprehend pricing page before scaling a high-volume pipeline.
3. Azure AI Language
Azure AI Language sentiment analysis and opinion mining is Microsoft’s sentiment API option.
It can detect sentiment and also do opinion mining, which Microsoft describes as a feature that links opinions to specific targets or aspects in text. The Azure how-to guide for sentiment analysis and opinion mining gives the classic example: “The room was great, but the staff was unfriendly.” Opinion mining can separate the room sentiment from the staff sentiment.
That is exactly what customer feedback often needs.
Because customers rarely write one clean emotional sentence.
They write messy mixed things like:
“Love the design, hate the checkout flow, support was nice though.”
A basic label may call this mixed.
Opinion mining gives you something more useful:
{
"design": "positive",
"checkout flow": "negative",
"support": "positive"
}
Why it is worth trying
Azure AI Language is a good fit if your company already uses Microsoft tools or Azure infrastructure.
Good fits:
- Microsoft/Azure apps.
- Customer feedback dashboards.
- Product review mining.
- Support and CRM workflows.
- Opinion mining.
- Enterprise NLP features.
- Power Platform or Azure Functions workflows.
- Apps that need Azure governance and identity controls.
What to watch
Microsoft’s docs now note that sentiment analysis and opinion mining in Azure Language are scheduled to retire on March 31, 2029, with migration guidance toward Azure AI Foundry models. That does not mean the API disappears tomorrow, but it does matter for long-term product planning. If you are building a new system in 2026, check the current Microsoft roadmap and migration docs before locking in.
4. IBM Watson Natural Language Understanding
IBM Watson Natural Language Understanding is a broader text analytics API that includes sentiment, emotion, entities, keywords, categories, relations, and semantic roles.
IBM’s Natural Language Understanding catalog page describes it as a service for analyzing text and extracting metadata such as concepts, entities, keywords, categories, sentiment, emotion, relations, and semantic roles.
That makes IBM interesting for enterprise text analytics where sentiment is one part of the picture.
For example, a product review pipeline may need:
sentiment + keywords + entities + categories + emotion
That is more useful than a lonely polarity label.
Why it is worth trying
IBM Watson NLU is a good fit when you need richer text analytics and enterprise-style workflows.
Good fits:
- Enterprise feedback analysis.
- Voice-of-customer dashboards.
- Employee feedback analysis.
- Content intelligence.
- Brand monitoring.
- Emotion detection.
- Entity and keyword extraction.
- Custom domain models through IBM tooling.
What to watch
IBM Watson NLU can do a lot, so the main question is whether you need the full package. If all you want is “positive/negative/neutral,” a lighter API may be easier. If you need richer analysis and enterprise controls, IBM becomes more interesting.
5. MeaningCloud
MeaningCloud Sentiment Analysis is worth a serious look if you want detailed multilingual sentiment rather than just a quick positive/negative label.
The MeaningCloud connector docs from Microsoft describe MeaningCloud’s sentiment analysis as a detailed multilingual sentiment analysis solution for texts from different sources. MeaningCloud has historically been strong around polarity, subjectivity, irony markers, agreement/disagreement, and multilingual analysis.
That makes it useful for messier feedback streams.
Example use cases:
- Surveys.
- News comments.
- Social posts.
- Reviews.
- Market intelligence.
- Voice-of-customer analysis.
- Public opinion tracking.
- Multilingual customer feedback.
Why it is worth trying
MeaningCloud is useful when you want more detailed sentiment signals and multilingual support.
Good fits:
- Multilingual feedback.
- Media monitoring.
- Public opinion analysis.
- Survey analysis.
- Social listening.
- Market research.
- Customer experience analytics.
- Teams that want more sentiment metadata.
What to watch
Detailed sentiment APIs can return many fields, which is great until your app has no idea what to do with them. Before integrating, define which fields matter for your workflow.
For example:
polarity → dashboard trend
irony → review flag
subjectivity → confidence filter
agreement → debate analysis
Do not collect 30 sentiment fields just because they look smart in JSON.
6. TextRazor
TextRazor is a text analysis API built around entity extraction, topics, relationships, classification, and other NLP features. Its REST API documentation explains that the main analysis endpoint can run several analyses in one call, such as extracting entities and relationships from the same document.
TextRazor is especially interesting when sentiment needs to sit next to entity understanding.
Because this is the kind of question that plain sentiment cannot answer well:
Are customers negative about our brand, our competitor, or the delivery company?
Entity-heavy analysis helps separate those signals.
Example:
“I love Acme’s app, but PayFlow keeps failing during checkout.”
A useful system should understand:
| Entity | Sentiment |
|---|---|
| Acme app | positive |
| PayFlow | negative |
That is the kind of analysis teams need for brand monitoring, market intelligence, and product research.
Why it is worth trying
TextRazor is useful when entities, topics, and relationships matter as much as sentiment.
Good fits:
- News analysis.
- Competitive intelligence.
- Brand monitoring.
- Entity-rich documents.
- Topic extraction.
- Knowledge graph workflows.
- Custom dictionaries.
- Research and media analytics.
What to watch
TextRazor may be more than you need for a simple “is this review angry?” feature. It shines when you care about what the text is talking about, not only the emotional tone.
7. Eden AI
Eden AI Sentiment Analysis APIs give you access to sentiment analysis through a unified platform.
The main idea is simple: instead of creating separate accounts and integrations for multiple providers, you call Eden AI and route sentiment analysis through available providers. Eden AI’s AI Gateway overview describes a unified gateway for many models and providers through one API.
This is useful if you want flexibility.
Maybe you want to test several sentiment providers. Maybe you want one API key. Maybe you want a fallback provider. Maybe you want batch processing. Eden AI’s help center also documents batch processing for sentiment analysis, which is handy when you need to process larger datasets.
Why it is worth trying
Eden AI is useful when you want sentiment analysis without committing to one provider too early.
Good fits:
- Multi-provider testing.
- Fast prototyping.
- Batch sentiment processing.
- Unified billing.
- Provider comparison.
- Apps with several AI features.
- Teams that want fallback options.
- Workflow automation.
What to watch
A gateway makes integration easier, but you still need to test the underlying providers. Two sentiment providers can disagree on sarcasm, mixed reviews, slang, or domain-specific language.
So use Eden AI to compare results, then decide which provider works best for your actual data.
8. APILayer Sentiment Analysis API
APILayer Sentiment Analysis API is a straightforward option if you want a simple API marketplace-style integration.
The APILayer sentiment API docs show a normal REST API pattern with JSON responses and standard HTTP status codes. APILayer also recently launched a broader unified suite, and its APILayer suite announcement describes one account, one key, and one dashboard for multiple APIs.
This is less “big enterprise NLP platform” and more “I need a usable API quickly.”
And honestly, sometimes that is the correct move.
Why it is worth trying
APILayer is useful when you want a lightweight sentiment feature without building a whole NLP stack.
Good fits:
- Small apps.
- Prototypes.
- Internal tools.
- Dashboards.
- Review widgets.
- Low-volume sentiment checks.
- Teams already using APILayer APIs.
- Simple positive/negative/neutral classification.
What to watch
If you need aspect sentiment, entity sentiment, multilingual nuance, custom models, or enterprise data pipelines, compare APILayer with Google, Amazon, Azure, IBM, MeaningCloud, and Eden AI first.
9. Repustate
Repustate focuses on sentiment analysis and text analytics for customer experience, employee experience, social listening, and multilingual analysis.
Repustate says its text analytics API supports sentiment analysis, named entity recognition, and topic detection across more than 23 languages on its text analytics API page. It also emphasizes language-specific processing, which is useful because translating everything into English before sentiment analysis can lose nuance.
That matters a lot for social listening.
A sarcastic Arabic tweet, a Spanish complaint, and an English review do not always behave nicely after translation. Tone can shift. Slang can disappear. Cultural context can get flattened.
Why it is worth trying
Repustate is worth testing if your work leans toward multilingual sentiment, social listening, or industry-specific customer experience.
Good fits:
- Multilingual social listening.
- Customer experience analytics.
- Employee feedback.
- Market research.
- Arabic sentiment analysis.
- Brand monitoring.
- Topic detection.
- Custom text analytics.
What to watch
Some Repustate public pages have not appeared as recently updated as the major cloud docs, so verify current pricing, API availability, and support details before choosing it for a new 2026 build.
10. Twinword Sentiment Analysis API
Twinword Text Analysis APIs include a Sentiment Analysis API that classifies text as positive or negative.
Twinword also appears through AWS Marketplace as a Text Analysis API Bundle, which lists sentiment analysis along with word associations, topic tagging, text classification, lemmatization, language scoring, and text similarity.
This is a lighter developer-friendly option compared with the big cloud providers.
Why it is worth trying
Twinword is useful if you want quick sentiment and related text analysis features without building a large NLP workflow.
Good fits:
- Lightweight apps.
- Prototypes.
- Text analysis demos.
- Simple sentiment scoring.
- Topic tagging plus sentiment.
- Developer experiments.
- Smaller-scale workflows.
What to watch
Twinword is better for simpler sentiment workflows. If your app needs sentence-level analysis, aspect sentiment, entity sentiment, or enterprise batch pipelines, test more specialized options too.
11. LLMAPI
LLMAPI fits a little differently from the others.
A classic sentiment API gives you labels and scores.
LLMAPI can help when sentiment analysis needs reasoning, explanation, routing, summarization, or workflow automation.
For example, a standard sentiment API might return:
{
"sentiment": "negative",
"confidence": 0.93
}
LLMAPI can help turn that into:
{
"customer_mood": "frustrated",
"main_issue": "billing confusion",
"urgency": "high",
"recommended_action": "route_to_billing_support",
"agent_note": "Customer is upset about being charged twice and wants a fast explanation."
}
That is useful because product teams usually need action, not just labels.
Where LLMAPI fits best
Use LLMAPI after or alongside sentiment analysis when you need:
- Sentiment explanation.
- Support ticket routing.
- Complaint summarization.
- Emotion-aware response drafts.
- Customer risk scoring.
- Review clustering.
- Escalation decisions.
- Topic plus sentiment summaries.
- Multi-model routing.
- Fallback when one model fails.
A practical workflow:
customer text
→ sentiment API
→ LLMAPI summary/routing
→ support queue or dashboard
Or:
customer reviews
→ sentiment analysis
→ LLMAPI groups complaints by theme
→ product team gets a readable report
This is where sentiment analysis becomes more than “vibes in JSON.”
Side-by-side comparison
Here is the practical comparison.
| API | Best for | Strongest angle |
|---|---|---|
| Google Cloud Natural Language | General cloud NLP | Sentence/document sentiment and entity sentiment |
| Amazon Comprehend | AWS apps | Batch, targeted sentiment, AWS data pipelines |
| Azure AI Language | Microsoft apps | Sentiment plus opinion mining |
| IBM Watson NLU | Enterprise text analytics | Sentiment, emotion, entities, categories |
| MeaningCloud | Multilingual detailed sentiment | Polarity and richer sentiment metadata |
| TextRazor | Entity-rich analysis | Entities, topics, relationships, sentiment context |
| Eden AI | Multi-provider access | One API for several sentiment providers |
| APILayer | Simple plug-and-play sentiment | Lightweight API integration |
| Repustate | Multilingual/social listening | CX, EX, topic detection, multilingual sentiment |
| Twinword | Lightweight developer workflows | Simple sentiment plus text analysis bundle |
| LLMAPI | Post-sentiment automation | Summaries, routing, explanations, workflows |
The best pick depends on what your app needs to do after it detects mood.
Which sentiment API should you choose?
Here is the no-drama version.
Choose Google Cloud Natural Language if you want a reliable general NLP API and your app already uses Google Cloud.
Choose Amazon Comprehend if your text data lives in AWS and you want sentiment, targeted sentiment, entity extraction, and batch workflows.
Choose Azure AI Language if you are building inside Microsoft/Azure and need opinion mining for customer feedback.
Choose IBM Watson Natural Language Understanding if you want sentiment plus emotion, entities, keywords, categories, and enterprise-style text analytics.
Choose MeaningCloud if multilingual and detailed polarity analysis matter.
Choose TextRazor if your text is entity-heavy and you care about who or what the sentiment is aimed at.
Choose Eden AI if you want one API layer to test and route between multiple sentiment providers.
Choose APILayer Sentiment Analysis API if you want something simple and quick to plug into a smaller app.
Choose Repustate if your work leans toward multilingual CX, EX, social listening, or topic detection.
Choose Twinword if you want a lightweight text analysis API with sentiment included.
Choose LLMAPI if you need to turn sentiment signals into summaries, routing, support notes, dashboards, or automation.
How to test sentiment analysis APIs properly
Please do not test sentiment APIs with three cute sample sentences.
Use your actual data.
Build a test set with:
- Positive reviews.
- Angry reviews.
- Mixed reviews.
- Sarcastic comments.
- Short support tickets.
- Long support tickets.
- App store reviews.
- Social posts.
- Multilingual text.
- Emojis and slang.
- Industry-specific vocabulary.
- Neutral-but-urgent messages.
- Complaints with polite wording.
- Praise with one hidden complaint.
- Messages that mention competitors.
Then track:
| Metric | Why it matters |
|---|---|
| Label accuracy | Does the label match human judgment? |
| Mixed sentiment handling | Can it handle “good product, bad support”? |
| Aspect accuracy | Does it know what the complaint is about? |
| Entity sentiment | Does it attach sentiment to the right brand/product? |
| Language quality | Does it work across your target languages? |
| Confidence calibration | Are high-confidence answers actually reliable? |
| Latency | Can it work in real-time support flows? |
| Batch speed | Can it process review datasets fast enough? |
| Cost per 1,000 texts | Does it scale with your volume? |
| Review usefulness | Does the output help humans act? |
The “review usefulness” part is underrated.
A sentiment API can be technically correct and still not help your team do anything.
What production output should look like
A production sentiment response should be structured enough for dashboards and workflows.
Example:
{
"text_id": "review_1042",
"language": "en",
"sentiment": {
"label": "mixed",
"score": -0.34,
"confidence": 0.89
},
"aspects": [
{
"target": "product quality",
"sentiment": "positive",
"confidence": 0.92
},
{
"target": "shipping",
"sentiment": "negative",
"confidence": 0.95
}
],
"emotions": {
"frustration": 0.82,
"satisfaction": 0.41
},
"recommended_action": "send_to_support_review"
}
That kind of output is useful because it separates the parts.
The app can show the dashboard. Support can see why the customer is upset. Product can count which features cause complaints. Leadership can stare at a chart and ask why shipping is emotionally destroying everyone this month.
Common mistakes when using sentiment analysis APIs
These are the usual traps.
| Mistake | Better approach |
|---|---|
| Using only positive/negative/neutral | Add aspect or entity sentiment when needed |
| Ignoring mixed sentiment | Separate product, support, pricing, delivery, etc. |
| Treating sarcasm as easy | Test sarcastic and slang-heavy data |
| No human-labeled test set | Build a real evaluation set |
| Ignoring confidence | Route low-confidence text to review |
| No language testing | Test every language you care about |
| No business rules | Decide what actually triggers action |
| No historical tracking | Store sentiment over time |
| No topic grouping | Sentiment without topic is vague |
| No follow-up workflow | Send signals somewhere useful |
The big one: do not build a dashboard full of sentiment scores that nobody acts on.
Sentiment should connect to action.
Where sentiment analysis gets tricky
Sentiment analysis has some classic trouble spots.
Sarcasm
“Fantastic. The app crashed again.”
The word “fantastic” is positive. The meaning is very much not.
Mixed feedback
“The product is great, but the onboarding was confusing and support took forever.”
Overall sentiment is messy. Aspect sentiment is better.
Domain language
“This model is sick.”
Could be good. Could be bad. Depends on context.
Neutral but urgent
“I was charged twice. Please fix this.”
The tone may be calm, but the issue is important.
Cultural and language nuance
A direct complaint in one language or region may look emotionally stronger than a complaint written in a more indirect style.
That is why your app should combine sentiment with:
- Topic.
- Intent.
- Urgency.
- Customer value.
- Account status.
- Support history.
- Business rules.
Mood is one signal.
It should not be the whole brain.
A simple sentiment workflow for customer support
Here is a practical workflow:
incoming ticket
→ detect language
→ analyze sentiment
→ extract topic/intent
→ classify urgency
→ route to queue
→ generate agent note
Example output:
{
"sentiment": "negative",
"emotion": "frustration",
"topic": "billing",
"urgency": "high",
"route_to": "billing_support",
"agent_note": "Customer appears frustrated about a duplicate charge. Prioritize a clear refund or billing explanation."
}
This is where LLMAPI can help after the sentiment API returns the mood signal.
The sentiment API detects emotional tone.
LLMAPI turns the result into an agent-friendly note or workflow decision.
A simple sentiment workflow for product reviews
For product teams, the workflow may look like this:
reviews
→ sentiment analysis
→ aspect extraction
→ group complaints by feature
→ weekly summary
→ product roadmap input
Example weekly summary:
Most negative feedback this week was about checkout speed, shipping delays, and confusing plan limits. Positive feedback focused on dashboard design and export features.
That kind of summary is way more useful than:
Average sentiment: -0.27
A score is fine.
A story is better.
The practical takeaway
The best sentiment analysis API in 2026 depends on your workflow.
Use Google Cloud Natural Language for general cloud NLP. Use Amazon Comprehend if your stack is AWS-heavy. Use Azure AI Language if you want Microsoft opinion mining and already live in Azure. Use IBM Watson NLU for broader enterprise text analytics. Use MeaningCloud for detailed multilingual sentiment. Use TextRazor when entities and topics matter. Use Eden AI when you want one API layer for multiple providers. Use APILayer when you need a simple plug-and-play API. Use Repustate or Twinword when they fit your multilingual, social listening, or lightweight text analysis needs.
And use LLMAPI when you want to turn sentiment into something your app can actually do:
detect mood
→ understand topic
→ summarize issue
→ route workflow
→ help the human respond better
That is the real point.
Sentiment analysis should help your app notice when customers are happy, annoyed, confused, disappointed, or one bad support reply away from leaving.
The API gives you the signal.
Your workflow decides what happens next.
