# AX Check: plivo.com Checked 2026-09-29. Plivo's quickstart, pricing, and SDKs are all readable and workable. 21 of 23 checks passed: quickstart code, install commands, and pricing tables are all directly usable. Only the homepage lacks a Markdown version. ## Onboarding needs a login ## Coding sessions All three independent sessions (DeepSeek V4.1 Flash, Kimi K3, Qwen 3.8 Max) completed the task and reported concrete per-message, per-minute, and per-number pricing sourced from Plivo's pricing pages, each flagging their own assumptions like pay-as-you-go rates versus enterprise plans and regional carrier fees. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/98d97156-7625-4a4c-b39f-e56dc231f1ac) · [Read transcript](https://www.ax-check.com/plivo.com/sessions/deepseek.json) README.md and final summary give per-message/per-number rates sourced from plivo.com/sms/pricing and plivo.com/pricing, and flag the assumption caveat that pricing may differ (Enterprise-only vs pay-as-you-go) for a new account. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never obtained Plivo credentials on its own. It only tested the SDK against a fabricated auth ID/token pair, which correctly failed with a 401 authentication error against the live api.plivo.com endpoint. No signup flow was run, no real Auth ID/Token was acquired, and no authenticated operation (e.g., an actual SMS send or number rental) succeeded. The agent explicitly told the user credentials are the missing piece. Event 132: ```text PLIVO_AUTH_ID=MA000000000000000000 PLIVO_AUTH_TOKEN=faketoken1234567890 PLIVO_FROM_NUMBER=+14151234567 timeout 25 .venv/bin/python plivo_sms.py +14157654321 "Hello from Plivo!" ``` Event 152: ```text Plivo API error: Failed to authenticate while accessing resource at: https://api.plivo.com/v1/Account/MA000000000000000000/Message/ ``` Event 165: ```text I don't have a Plivo Auth ID / Auth Token or a rented number, so I can't deliver a real SMS from here. That's a credentials boundary, not a product limitation. ``` #### Hallucinated URLs - **Guessed docs quickstart paths that returned 404**: The agent guessed several plausible but incorrect documentation URL patterns (e.g. language-specific quickstart slugs and a generic getting-started page) before finding the real quickstart via the llms.txt index. These guesses were not links copied from any page it had already fetched, and all failed with 404. This is a session-side guessing pattern rather than a broken official link, since the agent immediately found the correct path afterward via /docs/llms.txt. Event 33: ```text https://www.plivo.com/docs/sms/quickstart/python/ -> 404 https://www.plivo.com/docs/sms/quickstart/python ``` Event 33: ```text https://www.plivo.com/docs/getting-started/ -> 404 https://www.plivo.com/docs/getting-started ``` Event 27: ```text 404 https://www.plivo.com/docs/sms/quickstart/node ``` #### Blockers - **No self-service Plivo credentials available**: The sandbox environment had no Plivo Auth ID/Auth Token or rented phone number preloaded, and the agent has no way to complete Plivo's signup/10DLC registration itself. This is a test-environment/credentials limitation, not a product defect: the agent correctly identified it as an account boundary rather than a code problem and stopped short of a live send. Event 165: ```text I don't have a Plivo Auth ID / Auth Token or a rented number, so I can't deliver a real SMS from here. That's a credentials boundary, not a product limitation. ``` - **SDK ignores standard CA-bundle env vars, causing SSL failure behind sandbox proxy**: The Plivo Python SDK's RestClient calls requests.Session.send() directly, which does not respect REQUESTS_CA_BUNDLE/SSL_CERT_FILE. In this sandboxed network (behind a TLS-inspecting gateway), that caused a certificate verification failure on the very first live call. This is a product/SDK behavior interacting with the test environment's proxy; the agent worked around it by manually setting client.session.verify. Event 120: ```text requests.exceptions.SSLError: HTTPSConnectionPool(host='api.plivo.com', port=443): Max retries exceeded with url: /v1/Account/MA000000000000000000/Message/ (Caused by SSLError(SSLCertVerificationError(1, '[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1000)'))) ``` Event 148: ```text # The SDK calls session.send() directly, which ignores requests' normal # env-based CA handling. Honor the standard bundle if one is set, ``` #### Suggested Changes - **Fix the contradictory SMS pricing tier placement on the main pricing page**: The top-level pricing page (https://www.plivo.com/pricing/) lists 'SMS & Verify API' under the Enterprise plan starting at $1,000/month, while the dedicated SMS pricing page (https://www.plivo.com/sms/pricing/) advertises straightforward pay-as-you-go per-message rates ($0.0077/sms). A first-time developer reading only the main pricing page would conclude SMS requires an Enterprise contract. Reconcile the two pages so pay-as-you-go SMS eligibility is stated consistently, and confirm by re-fetching both pages and checking the SMS/Verify line item matches. Event 19: ```text Other Products Available in Enterprise plan only (starts at $1,000 /month) SMS & Verify API Messages start at $0.0077/sms View detailed pricing → ``` Event 32: ```text Route Type To send SMS (Outbound) To receive SMS (Inbound) Long Codes* $0.0077/sms $0.0077/sms ``` - **Add redirects or a link from the old /docs/sms/ path family to the current /docs/messaging/ path**: Multiple plausible SMS quickstart URLs under /docs/sms/... all 404, while the actual content lives under /docs/messaging/quickstart/quickstart. Adding 301 redirects from the old /docs/sms/* slugs (or at least linking them from the SMS overview page) would prevent developers and crawlers landing on dead ends. Verify by requesting https://www.plivo.com/docs/sms/quickstart/ and confirming it resolves instead of 404s. Event 33: ```text https://www.plivo.com/docs/sms/quickstart/ -> 404 https://www.plivo.com/docs/sms/quickstart ``` Event 63: ```text # Messaging API Quickstart ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/2b8f797a-6623-4256-8d58-05a37c0a6f51) · [Read transcript](https://www.ax-check.com/plivo.com/sessions/kimi.json) Final output gives per-message/per-minute/per-number pricing while naming assumptions (US rates, pay-as-you-go, trial verified-number restriction) and explicitly flags 'don't quote my numbers for anything real.' #### End-to-end onboarding - **Onboarding needs a login**: No self-service credential acquisition occurred. The agent found no Plivo credentials in the environment, never signed up for an account, and explicitly stated signup (email, phone verification, payment method) was something it could not do. All authenticated calls used deliberately dummy/invalid auth_id and auth_token values, which the SDK and API correctly rejected with 401/AuthenticationError. No real hosted product operation was ever completed. Event 8: ```text No Plivo credentials in the environment, so let me set up the SDK and build the example, then test how far I can get. ``` Event 39: ```text 401 Could not verify your access level for that URL. You have to login with proper credentials ``` Event 41: ```text I can't complete a live send because I have no Plivo account credentials — signup requires an email, phone verification, and (for full accounts) a payment method, none of which I can do. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No real Plivo account credentials available**: The sandbox environment had no PLIVO_AUTH_ID or PLIVO_AUTH_TOKEN, and the agent could not complete account signup itself since it requires email/phone verification and a payment method. This is a session/environment limitation (missing credentials), not a product defect — the agent correctly identified it needed normal human-provided signup and stopped short of an actual authenticated operation. Event 8: ```text No Plivo credentials in the environment, so let me set up the SDK and build the example, then test how far I can get. ``` Event 41: ```text Blocked at: I can't complete a live send because I have no Plivo account credentials — signup requires an email, phone verification, and (for full accounts) a payment method, none of which I can do. ``` - **Sandbox TLS/CA bundle blocks direct HTTPS verification**: When the agent tried to hit api.plivo.com directly with the plivo SDK, it hit an SSL certificate verification failure due to the sandbox's CA bundle, forcing a workaround using requests with verify=False. This is a test-environment artifact, not a Plivo product issue, and the agent itself noted this distinction. Event 35: ```text SSLError HTTPSConnectionPool(host='api.plivo.com', port=443): Max retries exceeded with url: /v1/Account/MAMMMMMMMMMMMMMMMMMM/Message/ (Caused by SSLError(SSLCertVerificationError(1, '[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1000)'))) ``` Event 41: ```text this sandbox's CA bundle doesn't verify api.plivo.com — a sandbox quirk, not a Plivo issue; the SDK works normally on a standard machine. ``` #### Suggested Changes None identified in this transcript. ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/bf46221d-fce3-41cb-b762-5f9a625a810d) · [Read transcript](https://www.ax-check.com/plivo.com/sessions/qwen.json) Final output gives per-bucket pricing (SMS ~$0.003-0.005, voice ~$0.0085/min, numbers ~$0.80-$2) and explicitly flags assumptions: pay-as-you-go model, US A2P 10DLC carrier fees on top, destination-dependent rates, and that figures are 'indicative' pending the account's authoritative rate card via the API. #### End-to-end onboarding - **Onboarding needs a login**: The agent never obtained real Plivo credentials. It downloaded the SDK and inspected source code to reverse-engineer the API surface, then built CLI tools, but every live-call path was gated behind placeholder credentials that were never replaced with real ones. All verification was done via --dry-run flags or by stubbing the SDK's transport layer (client.request) in unit tests, which is an explicit local mock, not an authenticated call to the real Plivo API. The agent explicitly states no message was ever sent and no live pricing was ever fetched. Event 229: ```text **No Plivo credentials**, so **nothing here has actually sent a message or fetched live pricing.** ``` Event 167: ```text These tests stub the SDK's transport layer (`RestClient.request`), so they run with NO real credentials and NO network access. ``` Event 152: ```text error: PLIVO_AUTH_ID/PLIVO_AUTH_TOKEN are still the placeholder values from .env.example. Put real credentials in .env, or re-run with --dry-run. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No real Plivo credentials available to make live API calls**: This is a session/environment limitation (no human supplied real Plivo Auth ID/Token), not a product defect. Plivo's SDK correctly validates credential format client-side and rejects placeholders, so the agent could not send an SMS, place a call, or fetch live pricing. It compensated with --dry-run flags and transport-layer mocked tests but never completed an authenticated operation against the hosted API. Event 229: ```text **No Plivo credentials**, so **nothing here has actually sent a message or fetched live pricing.** ``` Event 152: ```text error: Credentials are still placeholders, so the Pricing API cannot be called. Put real values in .env (from https://console.plivo.com/) and re-run. See README.md for the general pricing model in the meantime. ``` - **Voice example requires a public webhook URL not available in this session**: Product behavior: Plivo's Calls API requires answer_url to be a publicly reachable endpoint that returns Plivo XML when the call is answered. The agent correctly declined to spin up a local server (per the task's constraint against long-running local stacks) and instead only generated the XML document via a --print-xml flag, leaving the live call path untested. Event 137: ```text ``answer_url`` must be a PUBLICLY reachable URL that returns Plivo XML (PHLO-less call control). Plivo's cloud fetches it when the callee answers. This repo does not start a server for you ``` #### Suggested Changes - **Surface 10DLC/KYC cost impact earlier in official pricing docs or console flow**: The agent found through SDK source inspection that US A2P SMS requires 10DLC registration with carrier fees on top of the sticker rate, and flagged this as the item most likely to break cost estimates. Consider adding this caveat directly to the pricing page (plivo.com/pricing) or the Pricing API response itself, so it doesn't require reading source code or docs to discover. Event 215: ```text **US carrier / regulatory fees — the big hidden one.** Sending application-to- person (A2P) SMS to US numbers requires **10DLC registration**: a one-time brand + campaign vetting fee, plus ongoing **per-message carrier fees** on top of Plivo's rate. ``` - **Document the src/powerpack_uuid mutual exclusivity rule in the Messages.create docstring**: The agent's own transport-level test caught a real SDK behavior: passing both src and powerpack_uuid (even an empty-string src) raises a ValidationError, because the check uses 'is not None' rather than truthiness. This tripped up code written directly from the method signature. Add an explicit note in the messages.py create() docstring or public API reference showing this is checked with 'is not None', so integrators don't default src to an empty string when using powerpack_uuid. Event 173: ```text plivo.exceptions.ValidationError: Both powerpack_uuid and src cannot be specified. Specify either powerpack_uuid or src in request params to send a message. ``` ### Task given to each agent Help me build a simple example using Plivo. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop. No product credentials were supplied and no purchases were authorized. ## Score: B · 84/100 (provisional) Grades come from completed site checks. Coding sessions and skipped checks do not affect the score. ### Clarity - **Failed** — Homepage answers Markdown requests ```text Homepage returned text/html even when text/markdown was requested; no Markdown representation served. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt links to docs, API references, SDKs, CLI, MCP and pricing with organized sections. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt gives navigation guidance, directing to /docs/llms.txt and preferring specific product pages. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt mentions API references, the MCP server endpoint, and SDKs/CLI developer tools. ``` - **Pass** — A compact guide representation exists ```text Plivo publishes standalone Markdown guides, e.g. the Voice quickstart and Audio Streaming overview .md pages. ``` - **Pass** — A focused guide is directly retrievable ```text Voice quickstart .md returns 200 text/markdown with prerequisites, SDK install and first call steps. ``` - **Pass** — Equivalent instructions fit a token budget ```text Markdown quickstart is 3765 tokens vs 4499 HTML, well under the 8000-token budget. ``` - **Skipped** — Product-docs links survive format changes ```text Homepage Markdown is unsupported, so homepage link preservation across formats cannot be measured. ``` - **Pass** — The compact guide is independently actionable ```text Voice quickstart gives prerequisites, SDK install, outbound call code, inbound webhook setup, and next steps. ``` - **Pass** — Install and next-step links resolve ```text Homepage quickstart link and docs pages fetched successfully; install commands and next-step cards present. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text Voice API Quickstart gives concrete first steps: sign up, install SDK, make outbound call. ``` - **Pass** — Installation commands are extractable ```text Quickstart lists install commands per language: pip install plivo, npm install plivo, gem, composer, dotnet, go get. ``` - **Pass** — Code examples are available without interaction ```text Quickstart shows full code examples in Python, Node.js, Ruby, PHP, Java, .NET, Go, cURL without interaction. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text Prerequisites list signup, Auth ID/Auth Token from console, and renting a number; Basic Auth documented. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Pricing pages render full rate tables as static HTML with no interaction required. ``` - **Pass** — Prices are stated, not gated ```text Concrete prices stated: SIP $0.0010/min, AI agents $0.03/min, SMS $0.0077/sms. ``` - **Pass** — Pricing units and limits are explicit ```text Units explicit: per-minute, per-message, per-lookup, monthly rentals, concurrency limits. ``` - **Pass** — Agents identify pricing and its assumptions ```text 3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: README.md and final summary give per-message/per-number rates sourced from plivo.com/sms/pricing and plivo.com/pricing, and flag the assumption caveat that pricing may differ (Enterprise-only vs pay-as-you-go) for a new account. Kimi K3: Final output gives per-message/per-minute/per-number pricing while naming assumptions (US rates, pay-as-you-go, trial verified-number restriction) and explicitly flags 'don't quote my numbers for anything real.' Qwen 3.8 Max: Final output gives per-bucket pricing (SMS ~$0.003-0.005, voice ~$0.0085/min, numbers ~$0.80-$2) and explicitly flags assumptions: pay-as-you-go model, US A2P 10DLC carrier fees on top, destination-dependent rates, and that figures are 'indicative' pending the account's authoritative rate card via the API. This behavioural item does not affect the fast grade. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text Audio Streams API reference documents endpoints, parameters, and SDK examples. ``` - **Pass** — An MCP server is documented and well-formed ```text MCP server at https://plivo.com/docs/mcp with SearchPlivo tool and per-client setup. ``` - **Pass** — A CLI install path is documented ```text CLI install documented via Homebrew, Scoop, install.sh, and install.ps1. ``` - **Pass** — SDK packages resolve on their registries ```text PyPI plivo and npm plivo registry lookups both returned HTTP 200. ``` - **Pass** — Agent skills are published ```text Bundled agent skills (cli, audio-streaming, sip-trunking, voice-xml) installable via npx skills add. ``` [Full report data](https://www.ax-check.com/plivo.com/report.json)