Industries
Restaurants & Food
Take restaurant orders, table bookings and payments in one WhatsApp chat. Auto-reply to common questions and cut support costs with ChatMitra.
Real Estate
Use WhatsApp automation to capture property leads, qualify them automatically, and follow up fast. See how real estate agents close more with ChatMitra.
Travel & Tourism
Use the WhatsApp Business API to capture travel leads, send itineraries, confirm bookings, and keep travellers updated. See how agencies grow with ChatMitra.
Banking & Finance
Run secure KYC, send account alerts and payment notifications on WhatsApp. Cut support load and stay within Meta's rules with ChatMitra.
Beauty & Cosmetics
Sell your catalog, recover carts and win repeat orders on WhatsApp. Auto-reply to product questions and send launches to opted-in customers with ChatMitra.
Education
Answer admission enquiries, fee and timetable questions, and keep parents updated — all on WhatsApp. Cut admin load and costs with ChatMitra.
EduTech
Capture course leads, qualify them and onboard learners on WhatsApp. Automate replies and cut lead-qualification cost with ChatMitra's no-code chatbot.
Events & Webinars
Handle event registrations, reminders and RSVPs in one WhatsApp chat. Cut no-shows, automate FAQs and keep attendees updated with ChatMitra.
Freelancers & Consultants
Capture leads, send proposals and chase invoices in one chat. WhatsApp automation for freelancers and consultants with ChatMitra — from ₹0.20 a chat.
Health & Wellness
Book appointments, send reminders and answer client questions in one WhatsApp chat. Auto-reply to routine queries and cut support costs with ChatMitra.
Home Decor
Share your home decor catalog, take orders and send delivery updates on WhatsApp. Automate FAQs and cut support costs with ChatMitra.
IT Services
Use the WhatsApp Business API to qualify leads, run support over chat, and wire WhatsApp into your stack with webhooks. How IT companies scale with ChatMitra.
Marketing Agencies
Use WhatsApp automation to capture leads, run campaigns and manage multiple client brands from one account. How agencies scale on WhatsApp with ChatMitra.
Offline & Retail
Turn shop footfall into a WhatsApp list. Share catalogs, add a QR-to-chat at the counter and bring buyers back — with ChatMitra from ₹0.20 per chat.
Spas & Salons
Use the WhatsApp Business API to take spa and salon bookings, cut no-shows with automated reminders, and rebook regulars. How salons grow with ChatMitra.
Automotive
Use the WhatsApp Business API for automotive dealerships to qualify buyers, book test drives and send service reminders — automated, on one chat, with ChatMitra.
All Industries
Browse every industry guide
Back to WorkflowMitra Blog
Webhooks, APIs & Reliability

How to Read API Documentation When You Build Without Code

Hitesh Pathar
Hitesh Pathar
17 min read
A dense scribbled knot of thin teal line on the left unwinds into one straight line that threads through five neat tiles in a row reading Where, Who, What you send, What comes back and What can go wrong

Quick Summary

To read API documentation without being a developer, ignore most of the site and answer five questions from one endpoint page: where the request goes (base URL, method and path), who you are (authentication), what you send (path, query, header and body parameters with their types and units), what comes back (the response fields you'll use next) and what can go wrong (status codes, error codes and limits). Each answer maps to one field of a no-code HTTP Request step. Read the parameter table slowly: types decide whether a value goes in quotes, units decide whether ₹300 is 300 or 30000, and the example request settles any contradiction in the table. Test with sandbox keys before live ones.

You found an app that does what you need, and it has an API. Then you open the documentation and meet a wall of endpoints, code tabs in six languages, objects inside objects and words like “idempotent”. It’s easy to conclude the page isn’t meant for you.

It is. API documentation is written in a very repetitive way, and once you know the pattern you can read most of it without writing a line of code. This guide shows you how to read API documentation as a no-code builder: what to read, what to skip, how to decode the notation, and how every part of an endpoint page turns into a field in an HTTP Request step in WorkflowMitra, powered by ChatMitra. One real page, Razorpay’s “Create a Payment Link”, is used throughout so you can see each idea on an actual document.

Quick answer: to read API documentation, open the one endpoint page that does your job and answer five questions: where the request goes (base URL, method, path), who you are (authentication), what you send (path, query, header and body parameters, with their types and units), what comes back (the response fields you'll use next) and what can go wrong (status codes, error codes, limits). Each answer fills one field of a no-code HTTP Request step. When the parameter table and the example request disagree, trust the example, then confirm with one test call using sandbox keys.

What is API documentation?

API documentation is the manual for talking to a piece of software from the outside. It tells you which addresses accept requests, what each request must contain and what you get back. Developers read it to write code; a no-code builder reads it to fill in a form.

Most documentation sites mix four kinds of pages, and knowing which is which saves most of your reading time:

Page typeWhat it's forRead it?
Getting started / overviewThe base URL, test and live modes, how to get keysYes, first. Five minutes here prevents most early errors.
API referenceOne page per endpoint: its parameters, examples and errorsOnly the endpoint you need. This is where you'll spend your time.
Guides and tutorialsHow several calls fit together for a common jobWhen your job needs more than one call, such as "create a customer, then charge them".
SDKs, libraries, changelogCode packages for programmers; a history of changesSkip the SDKs. Glance at the changelog for your endpoint only.

The SDK pages are the ones that scare people off. They show the same request written in PHP, Python or Node.js, which only matters if you’re writing in that language. A workflow tool doesn’t need any of them. The one code sample worth your attention is the cURL example, because it’s the raw request with nothing hidden.

The five questions every endpoint page answers

An endpoint page can be long, but it only ever answers five questions. Read with these in mind and the page sorts itself into sections.

  1. Where does the request go? The base URL, the method (GET, POST, PUT, PATCH or DELETE) and the path. Together they make the address and the verb, such as POST https://api.razorpay.com/v1/payment_links/.
  2. Who are you? The authentication method: an API key, a bearer token, a username and password (basic auth) or OAuth. Usually described once, on its own page, and assumed on every endpoint after that.
  3. What do you send? The parameters: some in the path, some in the query string, some in headers and most, for create and update calls, in a JSON body. Each one has a name, a type, a “required” flag and a description.
  4. What comes back? The response: a status code and a body, usually JSON. You need the names and paths of the few fields you’ll use in later steps.
  5. What can go wrong? Error codes and messages, rate limits and any rule hidden in a description, such as “must be at least 15 minutes in the future”.

Here’s how those answers map onto WorkflowMitra’s HTTP Request step. Every field in the step’s form has a home in the documentation.

QuestionWhere the docs answer itHTTP Request field
WhereBase URL (overview page) + path (endpoint heading)URL
WhereThe verb beside the pathMethod
WhoAuthentication pageAuthentication type: No authentication, Bearer token, Basic auth or API key (header)
What you sendPath parametersTyped into the URL, usually as {{ }} values
What you sendQuery parametersQuery parameters rows
What you sendHeader parameters (version, content type, idempotency key)Headers rows
What you sendRequest body parametersBody content type: application/json · fields or Raw (JSON string)
What comes backResponse example and response parametersThe step's output: status, ok, headers, body
What can go wrongErrors section, rate limits pageAn IF on {{ ok }}; Advanced settings: Timeout (ms), On failure
A wooden shape-sorter board with five holes labelled URL, Method, Authentication, Query parameters and Body, and five matching pieces labelled with what an API page says, the base URL and path, POST, Basic auth, count=10 and a JSON block, each dropping into its own hole
Every section of an endpoint page has exactly one home in the request form. Read the page section by section and the form fills itself in.

If you’ve never set up the step itself, our guide on how to connect any API without code walks through the form and three working examples. This article stays on the reading side.

Read in this order

Docs sites are built for browsing, not for finishing a job. A fixed reading order keeps you from wandering:

  1. Overview or getting started. Note the base URL, whether there’s a separate sandbox URL, and whether test keys exist. Payment, messaging and shipping APIs almost always have a test mode; use it until the workflow works.
  2. Authentication. Find out what kind of credential you need, where to create it and which header carries it. Our guide to API authentication methods explains each type in plain terms.
  3. Your one endpoint. Search the reference for the verb of your job: “create”, “list”, “fetch”, “update”. Read that page top to bottom with the five questions.
  4. The errors section. Some sites put errors on each endpoint page, others on a shared page. Skim it before you test, so the first failure isn’t a surprise.
  5. Limits. Look for “rate limits”, “quotas” or “throttling”. If the docs say nothing, note that you don’t know, and pace any bulk job anyway.
  6. The changelog, briefly. Search it for your endpoint’s name. You’re checking for “deprecated”, “removed” or “requires version header”, nothing more.

That’s usually 15 to 20 minutes of reading for a well-documented API. If you find yourself on an SDK page, you’ve drifted.

How to read an endpoint page, section by section

Let’s read Razorpay’s Create a Standard Payment Link page the way you’d read any endpoint. It’s a good teaching page because it’s thorough, it uses real Indian units, and it contains two small contradictions of the kind you’ll meet everywhere.

The heading: method and path

At the top: POST /v1/payment_links/, under the base URL https://api.razorpay.com. That answers “where” in full. POST means you’re creating something, so expect a body. The /v1/ is the API version; it’s part of the address, so you copy it exactly.

Authentication

The page shows curl -u [YOUR_KEY_ID]:[YOUR_KEY_SECRET], and Razorpay’s authentication page confirms that every Razorpay API uses basic auth with a key ID and key secret. It also says the secret is shown only once, when you generate it, and that test-mode and live-mode keys are separate. So in the step you choose Basic auth, with the key ID as the username and the key secret as the password.

The parameter table

This is the heart of the page. Each row has four parts, and each part tells you something different:

  • Name, such as amount. Copy it character for character. APIs are case-sensitive, and Amount is a different field. Razorpay lists “extra fields sent” as an error, so a misspelt name doesn’t just get ignored.
  • Type, such as integer, string, boolean, object or array. This decides whether the value goes in quotes, and it’s the most common source of “but the value is right” errors. More on this below.
  • Required or optional. Fill every required field. Optional fields have defaults; Razorpay’s expire_by, for example, defaults to six months from creation.
  • Description. Read every word. Descriptions hide the rules: amount “must be in the smallest unit of the currency”, reference_id must be unique and at most 40 characters, and expire_by must be a Unix timestamp no more than six months ahead.

Nested fields appear indented under their parent, or with a dotted name. Razorpay lists name, email and contact under customer. In JSON that’s an object inside the body: "customer": {"name": "...", "contact": "..."}. When a doc writes customer.name or customer[name], it means the same thing.

The example request and response

On the right, or below the table, sits a cURL example and a sample response. Treat these as the tiebreaker. A table is written by hand and can drift; an example has usually been run at least once.

Razorpay’s page shows why. Its table marks upi_link as required, yet the description says that if upi_link “is not passed or passed with value as false, a Standard Payment Link will be created”. And it lists the type of notify as array, while the example sends an object: "notify": {"sms": true, "email": true}. In both cases the example and the description agree with each other, and the label is the odd one out. That pattern is common, so when a label surprises you, look at the example before you believe it.

The response parameters

The sample response shows what you’ll get back: an id starting plink_, a short_url you can send to the customer, a status (created, partially_paid, expired, cancelled or paid), the amount fields and several Unix timestamps. You don’t need all of it. Pick out the two or three fields later steps will use, here id and short_url, and note their paths.

The errors

At the bottom, Razorpay lists the error messages for this endpoint with their causes: “amount should be minimum 100 for INR”, “should be a whole number”, “timestamp must be atleast 15 minutes in future”, “payment link creation with reference ID already attempted”. Read these before your first test. Each one is a rule the table didn’t state plainly.

Decoding the notation

API docs share a small vocabulary of symbols. None of it is code; it’s shorthand.

You seeIt meansWhat you do
/payment_links/{id} or /payment_links/:idA path parameter: a slot in the addressReplace the whole {id} or :id, braces and colon included, with the real value
[YOUR_KEY_ID], <api_key>, YOUR_TOKENA placeholder for your own valueReplace it, brackets included. Never send the placeholder text
?count=10&skip=20Query parameters after the ?, separated by &One row each in Query parameters
string, integer, number, booleanText, whole number, any number, true/falseQuotes for strings only; numbers and true/false go in bare
string <date-time>, integer <int64>A type with a format hintFollow the format: ISO 8601 date-time, or a large whole number
enum, "possible values", "one of"Only the listed values are acceptedCopy one exactly; case matters
objectA group of named fieldsNested { } in JSON
array of objects, [ ]A list[ ] in JSON, even for one item
nullableThe field may come back as nullPlan for it being empty in later steps
Asterisk, "required", bold nameMust be sentFill it every time, and check the description for "only if"
... inside an example"More of the same, cut for space"Don't copy the dots

Reading types and units: where most errors hide

Two values can look identical on screen and be different to an API. 1000 is a number. "1000" is text that happens to contain digits. An API that declares amount as an integer may accept both, convert the text, or refuse it, and the documentation rarely tells you which. Send the type the table asks for and you never have to find out.

This matters in a no-code step for a specific reason. WorkflowMitra’s HTTP Request step has two JSON body modes:

  • application/json · fields builds the JSON from rows you fill in. It’s quick, but every value is sent as text. A row with amount = 1000 goes out as "amount": "1000".
  • Raw (JSON string) lets you write the body yourself. A value you leave unquoted, such as "amount": {{ amountPaise }}, goes out as a real number, and values inside quotes are escaped for JSON as they’re filled in. A name like Asha "A" Rao stays valid JSON.

We checked the cURL importer against Razorpay’s own sample on 20 October 2026. Razorpay’s example contains nested objects (customer, notify), so the importer kept it as a Raw body with every number and true/false intact. A flat example, with no nested objects, imports into the fields mode instead, and 1000 and false became the text values "1000" and "false". So after any import, check what mode the body landed in. Our guide to converting cURL commands lists the other checks.

Units are the second trap. The description, not the type, tells you the unit:

  • Money in the smallest unit. Razorpay wants paise: ₹300 is 30000, and its error list includes “amount should be minimum 100 for INR” (₹1) and “should be a whole number”. If your source has rupees, convert: {{ round(multiply(amount, 100)) }} turned 1250.50 into 125050 when we ran it.
  • Time in Unix seconds or milliseconds. expire_by is a Unix timestamp in seconds. WorkflowMitra’s timestamp() returns milliseconds, so {{ floor(divide(timestamp(), 1000)) }} gives “now” in seconds. Mix them up and you’re 1,000 times off.
  • Dates as ISO 8601. 2026-10-20T09:30:00Z style, with a time zone. Our guide to time zones in automation covers the Z.
  • Phone numbers. Some APIs want +919876543210, others 919876543210, others ten digits. The description or example decides. See formatting phone numbers to E.164.

One more detail when you write expressions: separate function arguments with commas, as in multiply(amount, 100). When we tried semicolons on 20 October 2026, the expression came back empty.

A huge ₹300 printed on a white sheet looks like one solid amount, but a magnifying glass resting on it shows the black ink is made of rows of tiny paise coins, beside a small label reading amount, integer, smallest unit of the currency
The type tells you whether a value goes in quotes; the description tells you its unit. ₹300 is 30000 to an API that counts in paise.

Path, query, header or body: telling parameters apart

Good docs group parameters under headings such as “Path parameters”, “Query parameters”, “Headers” and “Request body”. Weaker docs mix them in one table. When that happens, use the method and the example to sort them:

  • In the address, between slashes (/payment_links/{id}): a path parameter. Type it into the URL. If the value could contain a space, slash or &, wrap it in encodeURL(). WorkflowMitra inserts {{ }} values into the URL exactly as they are, so INV 1042/A would break the path, while {{ encodeURL(invoice) }} sends INV%201042%2FA.
  • After the ? (?from=…&to=…&count=2&skip=1): query parameters. Put each in its own Query parameters row; the step encodes these values for you. Razorpay’s Fetch All Payments page uses from and to (Unix seconds), count (default 10, maximum 100) and skip.
  • Shown with -H in the cURL example: headers. Common ones are Content-Type, a version header and an idempotency key. Authentication headers are usually better set through Authentication type.
  • Shown with -d or as a JSON block: body fields. GET requests normally have no body; if the docs show filters for a GET call, they’re query parameters.

Reading the response, and pointing to the fields you need

The response section shows what a successful call returns. Your job is to find the path to each value you’ll use. In WorkflowMitra, the HTTP Request step outputs status, ok, headers and body, and the API’s JSON sits under body. So Razorpay’s short_url becomes {{ body.short_url }} in the next step, or {{ $node["Create payment link"].body.short_url }} from any later step. Our guide to passing data between steps explains the two forms.

Watch for three response patterns:

  • Wrappers. List endpoints often wrap results. Razorpay’s Fetch All Payments returns "entity": "collection", a count and an items list, so the first payment is body.items[0], not body[0].
  • Response headers. Rate-limit counters and pagination links sometimes live in headers, not the body. WorkflowMitra stores header names in lower case, so read them as headers["x-ratelimit-remaining"], whatever case the docs print.
  • Nullable fields. Razorpay’s payments is null until someone pays. A later step that reads it must expect an empty value. Our guide to empty values in automation has the patterns.

Reading the errors section

Errors come in two layers, and the docs usually describe both:

  1. The HTTP status code: 400 for a bad request, 401 for failed authentication, 404 for not found, 429 for too many requests, 5xx for a problem on their side.
  2. The error body: the API’s own code and message, often more useful than the status.

The two don’t always match the way you’d guess. When we sent Razorpay a request with made-up keys on 20 October 2026, it answered status 401 with this body:

{"error": {"code": "BAD_REQUEST_ERROR", "description": "Authentication failed"}}

The status says authentication; the code says bad request. Route your workflow on the status, and log the description for whoever fixes it.

In WorkflowMitra, a 4xx or 5xx response doesn’t stop the run. The HTTP Request step finishes with ok set to false and the status and body in its output, so add an IF on {{ ok }} (Is yes) after any call that matters. Timeouts and network errors are different: they fail the step unless Advanced settings › On failure is set to Continue. Our HTTP status codes guide shows which errors to retry and which to fix.

The sections people skip: pagination, limits, versions and environments

These rarely matter on day one and often matter in week three.

Pagination. A list endpoint returns one page at a time. Docs describe it in one of a few styles: page number and page size, offset and limit (Razorpay’s count and skip), a cursor or “next” token in the response, or a link in a response header. Note the maximum page size and how you’ll know you’ve reached the end, usually a page with fewer items than you asked for, or no next cursor.

Rate limits. Look for requests per second, minute or day, and what happens when you cross the line, normally a 429 with a Retry-After header. If the docs give no number, as Razorpay’s authentication page doesn’t, keep bulk jobs slow and treat 429 as “wait”. Our API rate limit guide covers pacing in workflows.

Versions. Versions live in the path (/v1/), in a header (LinkedIn-Version: 202510 style) or in a date. If a header version is required, every request needs it, and old versions are retired on a schedule the changelog announces.

Environments. Test and live keys, sometimes separate base URLs, sometimes features that only exist in one. Razorpay’s own error list says UPI payment links aren’t supported in test mode, and test mode allows up to 30 payment links per business. Read the environment notes before you decide a feature is broken.

Webhooks. Many docs have a webhooks section. That’s the opposite direction: the app calling you when something happens. You read it to set up a trigger, not a request. Our introduction to what webhooks are explains the difference.

Documentation formats you’ll meet

The same information arrives in a handful of layouts:

  • OpenAPI (Swagger) sites. Many reference sites are generated from an OpenAPI description, a standard file format for REST APIs. Generated pages, such as those built with Swagger UI, look alike: endpoints grouped by resource, a coloured method badge, parameter tables and an expandable schema. Some have a “Try it out” button that sends a real request from the page.
  • Three-column references. Navigation on the left, explanation in the middle, code examples on the right. Razorpay’s pages follow this layout. The right column is where the cURL example lives.
  • Postman collections. Some companies publish their API as a Postman collection, a saved set of ready-made requests. Each request shows the method, URL, headers and body in separate tabs, which map straight onto the step’s fields.
  • GraphQL docs. One URL, and a query language instead of many endpoints. They read differently; see using a GraphQL API without code.
  • A PDF or a single long page. Common with Indian SMS gateways, courier partners and older ERPs. The five questions still apply; you just have to find the answers yourself.

Worked example: from Razorpay’s page to a working step

Here’s the whole reading turned into a step that creates a payment link for an order and sends it on. The step just before it is a Set Variable step holding orderId, customerName, phone and amount (in rupees), so the request can read them with plain {{ }} placeholders.

  1. Overview. Base URL https://api.razorpay.com. Use test-mode keys while building.
  2. Authentication. Generate test keys in the Razorpay Dashboard (Account & Settings › API Keys). Copy the secret straight away; Razorpay won’t show it again. In WorkflowMitra: Authentication type = Basic auth, key ID as username, key secret as password.
  3. Method and URL. POST, https://api.razorpay.com/v1/payment_links/.
  4. Body. Choose Raw (JSON string), because amount must be an integer and notify holds true/false values:
{
  "amount": {{ round(multiply(amount, 100)) }},
  "currency": "INR",
  "reference_id": "{{ orderId }}",
  "description": "Payment for order {{ orderId }}",
  "customer": {
    "name": "{{ customerName }}",
    "contact": "{{ phone }}"
  },
  "notify": { "sms": false, "email": false },
  "reminder_enable": true
}
  1. Check every rule from the descriptions. amount is in paise and at least 100. reference_id is unique per link and at most 40 characters, so an order ID works and a retry with the same ID is refused instead of making a second link. expire_by is left out, so the link lasts the default six months. If you need it, it must be Unix seconds, at least 15 minutes ahead and within six months: {{ subtract(floor(divide(timestamp(), 1000)), subtract(0, 86400)) }} gives “now plus one day” (the double subtraction adds 86,400 seconds), and goes in unquoted.
  2. Test behind a manual trigger. Run once with test keys and sample data. Read status and body in the run. A 200 with an id starting plink_ means the request is right.
  3. Guard and use the result. Add an IF on {{ ok }} (Is yes). On the yes branch, use {{ $node["Create payment link"].body.short_url }} in your message. To send it on WhatsApp, use an approved template through the WhatsApp step; ChatMitra’s guide to sending a payment link on WhatsApp covers the template side. On the no branch, alert yourself with {{ status }} and {{ body.error.description }}.

Each HTTP Request step uses 1 WorkflowMitra credit per run, including calls that return an error, and IF steps are free. Razorpay charges its own fees on payments collected; check its pricing page for those.

What to do when the documentation is thin

Not every API is documented as well as Razorpay’s. When answers are missing:

  • Find any example request. A single cURL example answers more questions than a page of prose. Search the docs, the vendor’s help centre and their public Postman workspace.
  • Send the smallest possible request. Required fields only, test keys, behind a manual trigger. The error message often names the missing or wrong field.
  • Read the error carefully. “faulty key: expire_by” or “extra fields sent” is the API telling you exactly what to fix.
  • Check the date. An old forum answer may describe a retired version. Prefer the vendor’s changelog.
  • Ask support with a precise question. Include the endpoint, your request body (with secrets removed) and the full response. You’ll get a better answer than “it doesn’t work”.
  • Don’t guess with live keys. A wrong guess on a payments or messaging API can charge a customer or send a real message.

Common mistakes when reading API docs

MistakeWhat happensFix
Reading an SDK page instead of the referenceYou copy library calls that no HTTP step understandsUse the cURL example and the parameter table
Leaving {id} or [YOUR_KEY] in place404 or 401 with a confusing messageReplace placeholders, brackets included
Numbers sent as textType errors, or a value silently treated differentlyRaw JSON body with unquoted values
Rupees where paise are wantedA link for ₹3 instead of ₹300Read the unit in the description; multiply by 100
Seconds and milliseconds mixed upDates in 1970 or in the far futureDivide timestamp() by 1000 for Unix seconds
Trusting a "required" label over the exampleSending fields you don't need, or the wrong typeLet the example and description settle it; test once
Building with live keysReal charges or real messages while testingTest mode first, live keys last
Ignoring ok: falseThe workflow carries on as if the call workedIF on {{ ok }} after every important call

A one-page worksheet for any endpoint

Copy this into a note before you build. When every line is filled, the step is ready to configure.

  • Base URL, and the sandbox URL if different
  • Method and path, with each path parameter named
  • Authentication type, where the key comes from, and test vs live
  • Required body fields, with type and unit for each
  • Optional fields you’ll use, and their defaults
  • Query parameters, including page size and filters
  • Required headers (version, content type, idempotency)
  • The response paths you’ll use later, such as body.short_url
  • The errors you expect, and what the workflow should do for each
  • Rate limit, or “not stated”
  • Anything in the changelog that affects this endpoint

Read once, build with confidence

API documentation stops being intimidating when you stop reading it like a book. Pick one endpoint, answer the five questions, respect the types and units, and let the example settle any doubt. The same habits work for a payments API, a CRM, a shipping partner or an SMS gateway.

WorkflowMitra, powered by ChatMitra, gives you an HTTP Request step with Import from cURL, basic, bearer and API-key authentication, raw JSON bodies and an ok flag to route on, plus the IF, WhatsApp, Google Sheets and Slack steps that use what the API returns. Browse the templates or the feature overview, then try your first documented endpoint on a WorkflowMitra trial: 14 days, no card needed. When the request works, test the full workflow and add error handling before you switch it on. For a second practice document, ChatMitra’s own WhatsApp API reference uses the same patterns.

Sources: Razorpay Docs, Create a Standard Payment Link, Fetch All Payments and Authentication; OpenAPI Initiative, What is OpenAPI?; SmartBear, Swagger UI; Postman Learning Center, Collections overview; all read 20 October 2026. Razorpay's 401 response was observed with made-up keys on 20 October 2026. WorkflowMitra behaviour checked in the product source code, by running the cURL importer on Razorpay's examples and by running the expressions shown through the expression engine on 20 October 2026. Order IDs, names and amounts are illustrative.

FAQ

Frequently Asked Questions

Short answers to common questions about reading API documentation.

Skip the SDK and library pages and open the one endpoint that does your job, such as "Create a payment link". Answer five questions from that page: where the request goes, how you authenticate, what you send, what comes back and what can go wrong. Each answer fills one field of a no-code HTTP Request step, and the example request at the side of the page shows all five together.

WorkflowMitra, powered by ChatMitra

Automate the work between your apps

Build workflows with triggers, conditions and actions, then test them before they go live. Try WorkflowMitra free for 14 days, no card required.