API Dizain: REST vs GraphQL vs gRPC — Kaise Chunen

Har aadhunik aplikasyon doosre applications se APIs ke madhyam se baat karta hai. Sawaal ab yah nahi hai ki API banaye ya nahi, balki yah hai ki kaun sa style API banana hai. REST ek dashak se adhik samay se default raha hai. GraphQL REST ki anyata ke pratikriya ke roop mein udbhavit hua. gRPC ek bilkul alag drishtikon leta hai jo HTTP/2 aur protocol buffers par nirmit hai. Unke beech chunne ke liye sirf syntax nahi, balki antareek dizain philosophy ko samajhna avashyak hai jiska pratyek pratinidhitv karta hai.

Yah guide pratyek protocol ko dizain drishtikon se tor deti hai: aap sansadhanon ya schemas ko kaise sanrachit karte hain, clients aapke API ke saath kaise interact karte hain, aap versaning aur pagination kaise sambhalte hain, aur vaastav-samay avashyaktayen nirnay ko kaise prabhavit karti hain. Ant tak, aapke paas apne vishesh nirbandhon ke liye sahi upkaran chunne ka ek dhancha hoga.

REST: Sansadhan-Unmukh Dizain Jise Web Samajhta Hai

REST — Representational State Transfer — ek protocol nahi hai. Yah ek sthapatya shaili hai jise Roy Fielding ne 2000 mein apne doctoral nibandh mein paribhashit kiya. Mool vichar yah hai ki aap apne domain ko sansadhanon ke roop mein model karte hain, pratyek ek URL se pahchana jata hai, aur aap un sansadhanon ko HTTP verbs ke ek samaan set ke madhyam se samvedan karte hain: GET, POST, PUT, PATCH, aur DELETE.

Achchha REST API dizain sansadhan-unmukh dizain hai. Aap end points ko kriyaon ke aaspaas dizain nahi karte — aap end points ko sangyaon ke aaspaas dizain karte hain. /createUser ya /getUserById ke bajay, aap POST /users aur GET /users/:id dizain karte hain. Yah chhota antar lagta hai, lekin yah gehrai se prabhavit karta hai ki API kaise scale karti hai, kaise dastavejit hoti hai, aur clients ise kaise upyog karna seekhte hain.

GET /users/42
Accept: application/json

Response 200:
{
  "id": 42,
  "name": "Ada Lovelace",
  "email": "ada@example.com",
  "role": "admin",
  "createdAt": "2025-11-14T09:00:00Z"
}

REST ki sundarta iski saralta hai. URL sansadhan ki pahchan karta hai, HTTP method kriya ki pahchan karta hai, aur pratikriya body pratinidhitv rakhti hai. Har bhasha mein har HTTP client is anubandh ko samajhta hai. Caching HTTP headers ke madhyam se box se bahar kaam karta hai. OpenAPI (pahle Swagger) jaise upkaran aapko ek schema file se documentation, client SDKs, aur server stubs generate karne dete hain.

REST mein samasya tab hoti hai jab clients ko data ke alag aakar chiye. Ek mobail client ko sirf user ka naam aur role chahiye, jabki ek dashboard client ko nested organization data ke saath poora profile chahiye. REST ke saath, aap ya kai endpoints banate hain ya har client ko pura pratinidhitv download karne aur jo nahi chahiye usse tyag karne ke liye majboor karte hain. Yah over-fetching samasya hai, aur yah GraphQL ki pramukh prerna thi.

GraphQL: Client Theek Se Bataye Ki Use Kya Chahiye

GraphQL, Meta dvara vikasit aur 2015 mein jar, viprit drishtikon leta hai. Server nishchit pratikriyaen paribhashit karne ke bajay, client ek query bhejta hai jo theek vahi data varnit karta hai jo vah chahta hai, aur server theek vahi aakar vapas karta hai. Ek end point, koi bhi pratikriya aakar.

GraphQL schema aapke domain mein types aur sambandhon ko paribhashit karta hai. Client is schema ke virudh queries banata hai, sirf un fields ka anurodh karta hai jinki use avashyakta hai. REST ke nested sansadhanon ki vahi avdhaarna GraphQL query mein nested fields ban jati hai, lekin client gahrai aur chunaav ko niyantrit karta hai.

type User {
  id: ID!
  name: String!
  email: String!
  role: Role!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  body: String!
}

enum Role { USER ADMIN MODERATOR }

type Query {
  user(id: ID!): User
}

Ek client jise sirf user ka naam aur post titles chahiye, vah query bhejta hai jo theek un fields ke liye puchhti hai:

query {
  user(id: 42) {
    name
    posts {
      title
    }
  }
}

{
  "data": {
    "user": {
      "name": "Ada Lovelace",
      "posts": [
        { "title": "Notes on the Analytical Engine" }
      ]
    }
  }
}

GraphQL mein key dizain siddhant yah hai ki schema anubandh hai. Schema paribhashit karta hai ki kya sambhav hai, aur client nirnay karta hai ki uplabdh vikalpon mein se kya anurodh karna hai. Yah over-fetching samapt karta hai, netvarak anurodhon ki sankhya kam karta hai (ek akeya query kai REST raund-trips ko badal sakti hai), aur frontend teams ko backend parivartanon se svatantra karta hai kyunki naye client avashyaktayon ko hamesha naye endpoints ki avashyakta nahi hoti.

GraphQL apni jटilta bhi parichit karta hai. Query pradarshan ka poorvanuman karna kathin hai kyunki client niyantrit karta hai ki kya load ho. N+1 samasya — jahan nested fields hal karne se har parent record ke liye ek svatantra database query chhiddi — DataLoader jaise batchng samadhanon ki avashyakta karti hai. HTTP star par caching kaam nahi karta kyunki har query ek hi POST end point se takrati hai, isliye application-star caching ranneetiyan avashyak hain. Aur resolver, mutations, subscriptions, aur input types ke liye seekhne ki avakr REST ke seedhe URL-aur-verb model se adhik tikhari hai.

GraphQL frontend teams ko backend parivartanon se svatantrata deta hai. Lekin vah svatantrata har query ke pradarshan visheshtao ko samajhne ki jimmedari ke saath aati hai jo aapka klient server ko bhejta hai.

gRPC: HTTP/2 aur Protobuf Par Nirmit Uchch-Pradarshan RPC

gRPC, mul roop se Google dvara vikasit, ek aur drishtikon leta hai. Sansadhanon aur queries ke bajay, gRPC APIs ko door se prakrriya call ke roop mein model karta hai — aap ek seva ko vidhiyon ke saath paribhashit karte hain, aur clients un vidhiyon ko sthaaniy functions ki tarah call karte hain. Key takniki antar yah hai ki gRPC JSON ke bajay serialization ke liye Protocol Buffers (protobuf) aur transport ke liye HTTP/1.1 ke bajay HTTP/2 ka upyog karta hai.

syntax = "proto3";

service UserService {
  rpc GetUser (GetUserRequest) returns (User);
  rpc ListUsers (ListUsersRequest) returns (ListUsersResponse);
  rpc CreateUser (CreateUserRequest) returns (User);
  rpc StreamUserUpdates (StreamRequest) returns (stream UserUpdate);
}

message GetUserRequest {
  int32 id = 1;
}

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  Role role = 4;
  string created_at = 5;
}

enum Role { ADMIN = 0; USER = 1; }

message StreamRequest {}

message UserUpdate {
  User user = 1;
  string event_type = 2;
}

Protobuf ek sancheet baenari format mein serialise karta hai jo JSON se kaafi chhota aur parse karne mein tez hota hai. HTTP/2 ke multiplecsing — ek akeya sansar par kai streams — ke saath milkar, gRPC adhik-maatra sanchaar ke liye REST ya GraphQL ki tulna mein natakiy roop se kam villamb aur adhik throughput prapt karta hai. Yah gRPC ko microservices-se-microservices sanchaar ke liye pradhan vikalp banata hai, jahan serialization atirikt ke har milisecond aur tar par har byte maayne rakhta hai.

gRPC mool roop se char prakar ke streming bhi samarthan karta hai: unary (ek anurodh, ek pratikriya), server-streaming (ek anurodh, pratikriyaon ki dhara), client-streaming (anurodhon ki dhara, ek pratikriya), aur bidirekshanal streaming (dono aur ek saath stream). Yah teeno protocols mein se vaastav-samay APIs ke liye sabase majbooth vikalp banata hai.

Samjhauta yah hai ki gRPC browsers se upyog karna kathin hai. Browser clients seedha gRPC sevaon tak nahi pahunch sakte kyunki unke paas HTTP/2 frames par sookshm niyantran ka abhav hai. gRPC-Web ek kaary-panah ke roop mein maujood hai lekin jटilta jodta hai. Protobuf sandesh yaataayata mein maanav-drishtya nahi hote, jo debugging ko kathin banata hai — traffic ka nirikshan karne ke liye aapko grpcurl ya reflection service jaise upkaranon ki avashyakta hoti hai. Aur API documentation ke liye ecosystem OpenAPI ya GraphQL ke introspection system se kam paripakv hai.

Vyavaharik Chintaaon Mein Unki Tulna

REST, GraphQL, aur gRPC ke beech chunaav shayad hi ek pure takniki nirnay hota hai. Sahi chunaav is par nirbhar karta hai ki aapke clients kaun hain, unhe kis tarah ke data ki avashyakta hai, aur aapke netvarak aur infrastructure ke nirbandh kya hain. Yahaan har protocol ki tulna vyavaharik chintaaon ke aadhaar par hai jo production mein sabase adhik maayne rakhti hain.

API Versaning

REST versaning URL ya Accept header ke madhyam se sambhalta hai. /v1/users aur /v2/users aseemat roop se ek saath rah sakte hain, clients ko apni gati se sthanantar karne dete hain. Yah saral aur yudhsiddh hai, lekin yah dupliketan ko protsahit karta hai — v2 endpoint aksar kuchh parivartanon ke saath v1 ke adhiktar tark ko duplikat karta hai. GraphQL schema ko vikasit karke versaning se poore tarah bachta hai. Ankith fields ko @deprecated nirdesh se sajaya jata hai aur schema mein tab tak rahta hai jab tak har client sthanantar nahi kar leta. Yah tab achchha kaam karta hai jab aap sabhi clients ko niyantrit karte hain lekin janata APIs mein ghnarsh paida kar sakta hai jahan clients dheeme update hote hain. gRPC ka protobuf schema agrim-anukool hai dizain se — aap bina maujooda clients ko todhe fields jod sakte hain, aur ankith fields sthanantar avadhi ke baad hata di jati hain. Yah teeno mein sabase elegant versaning strategy hai, lekin isme kisi field ko kangiren ya hatane ke liye anushaasan chahiye bina alpkalay ki avadhi ke.

Pagination Pratiroop

REST pagination aamtaur par nextCursor field ke saath kursar-aadharit, ya page aur limit parameters ke saath offset-aadharit hoti hai. Dizain siddhant yah ki pratikriya mein next link ya token hota hai, aur client uska palan karta hai. GraphQL pagination Relay Connection spec ka upyog karti hai, jo liston ko cursons aur page jankari ke saath edges mein lapeti hai — adhik shrutipat lekin ad hoc REST drishtikonon se adhik sanagat. gRPC pagination anurodh aur pratikriya sandeshon mein haath se sambhali jati hai, aamtaur par page_token aur page_size field ke saath. Koi manak nahi hai, lekin protobuf schema anubandh ko spasht banata hai.

• REST: pratikriya mein nextCursor ke saath kursar-aadharit pagination production APIs ke liye anushansit pratiroop hai
• GraphQL: Relay Connection spec hasNextPage, hasPreviousPage, aur cursors ke saath ek manakikrit pagination model pradan karta hai
• gRPC: pagination aapke proto sandeshon mein paribhashit hota hai; ek aam pratiroop anurodh mein page_token aur page_size aur pratikriya mein next_page_token shamil karna hai

Pramanikikaran aur Adhikaran

Teeno protocols ek hi antareek transport suraksha par nirbhar karte hain. REST aamtaur par Authorization header mein Bearer tokens ka upyog karta hai. GraphQL usi pratiroop ka palan karta hai — kyunki saare anurodh ek akeya POST end point se hote hain, token GraphQL star ya middleware mein maanyata ki jati hai. gRPC pratyek call mein pramanikikaran metadeta jodne ke liye interceptor ka upyog karta hai, aamtaur par gRPC metadata headers mein JWT tokens ke roop mein. Koi bhi protocols kisi vishesh pramanikikaran vidhi ka aadesh nahi deta — OAuth2, API keys, ya session-aadharit auth ka chunaav API style se svatantra hai.

Rate Limiting

Rate limiting REST ke saath sabase saral hai kyunki har end point ek baddh prakritya darshta hai. Aap prati end point prati client anurodhon gin sakte hain aur seema paar hone par 429 Too Many Requests vapas kar sakte hain. GraphQL rate limiting ko kathin banata hai kyunki ek akeya query vastu roop se alag maatra ka kaam chhedh sakti hai — ek field ki query ek database lookup ki laagat ho sakti hai, jabki gehrai se nested sambandhon ki query chamchas ki laagat ho sakti hai. GraphQL APIs aamtaur par laagat-aadharit rate limiting implement karti hain, jahan har field ka ek bhaar hota hai aur exikyushan se pahle kul query laagat ganit ki jati hai. gRPC rate limiting REST ke samaan hai lekin vidhi star par karti hai — aap prati client prati vidhi RPC calls gin sakte hain, is atirikt vichar ke saath ki streaming calls apni avadhi ke liye sansadhan upyog karti hain, na ki sirf apni shuruaat ke liye.

Vaastav-Samay API aur Streaming

REST WebSockets ya Server-Sent Events ke madhyam se vaastav-samay update sambhal sakta hai, lekin dono REST specification ka hissa nahi hain — ve alag protocols hain jo HTTP API ke saath jude hain. GraphQL ke subscriptions hain, jo specification ka pratham-shreni hissa hain. Client ek ghatna ki sadasyata leta hai aur WebSocket sansar par updates prapt karta hai jab bhi ghatna hoti hai. gRPC ke paas HTTP/2 par native bidirekshanal streaming ke saath sabase majbooth vaastav-samay kahani hai. Ek akeya gRPC call ek hi samay dono dishaon mein data stream kar sakti hai, jo vaastav-samay dashboards, chat applications, aur event-sanchalit pranalion ke liye aadarsh hai. Yadi vaastav-samay sanchaar ek pramukh avashyakta hai, gRPC ki streaming sabase paripakva aur pradarshan-kushal vikalp hai, uske baad GraphQL subscriptions, aur uske baad REST plus WebSockets.

Documentation aur Developer Experience

REST ke paas OpenAPI (pahle Swagger) ki baad-dhanyavad documentation ecosystem hai. Ek OpenAPI vinirdesh pratyek end point, anurodh paramiter, pratikriya schema, aur pramanikikaran vidhi ko ek machine-padhy YAML ya JSON file mein varnit karta hai. Swagger UI jaise upkaran ise ek interaktif documentation page mein render karte hain, aur code generaer dozens bhashaon ke liye client SDKs utpann karte hain. Is ecosystem ki paripakvta ka arth hai ki ek naya developer OpenAPI spec padhne se lekar apni pehli safal API call karne tak minute mein pahunch sakta hai.

GraphQL ke paas introspection hai — ek nirmit pranali jahan aap API ke schema ko ek vishesh end point ke madhyam se query kar sakte hain. GraphiQL aur Apollo Studio Explorer jaise upkaran developers ko schema browse karne, autocomplete ke saath queries likhne, aur inline documentation dekhne dete hain. Yah un developers ke liye ek achchha anubhav hai jo pahle se jante hain ki aapka API maujood hai, lekin yah sarch engine khoj yogyata ya bahari API bazaaron mein madad nahi karta jis tarah OpenAPI spec karta hai.

gRPC proto files ko apne sach strot ke roop mein upyog karta hai. Proto file dono schema aur documentation hai. protoc-gen-doc jaise upkaran proto files se sandarbh documentation utpann karte hain, aur gRPC reflection clients ko services dinamik roop se khojne deti hai. gRPC ka developer experience sudhar raha hai lekin abhi bhi upkaran paripakvta mein REST aur GraphQL se pichhe hai, khas taur par microservices ecosystem ke bahar.

Pratyek Kab Upyog Karein

REST sahi vikalp hai jab aapka API bahari developers upbhog karte hain, jab aapko adhiktam antar-karyata chahiye, aur jab aapke clients ko manak HTTP caching ki avashyakta hai. Yah sabase surakshit default hai kyunki har bhasha, dhancha, aur proxy HTTP samajhta hai. Yadi aap ek janata API bana rahe hain, REST se shuru karein.

GraphQL sahi vikalp hai jab aapke API ke kai client types hain alag data avashyaktayon ke saath, jab frontend teams ko backend parivartanon se svatantra roop se chalne ki avashyakta hai, aur jab aap netvarak anurodhon ki sankhya kam karna chahte hain. Yah upabhokta-unmukh applications mein utkrisht hai mobail aur web clients ke saath jinhe ek hi data ke alag aakar chiye.

gRPC antarik microservices sanchaar ke liye, uchch-throughput pranalion ke liye jahan serialization atirikt maayne rakhta hai, aur vaastav-samay streaming applications ke liye sahi vikalp hai. Yadi aap ek aisi pranali bana rahe hain jahan dono aapke niyantran mein hain aur pradarshan pramukh chinta hai, to gRPC sabase majbooth vikalp hai.

Inmein se koi bhi protocols parspar vanchit nahi hain. Ek aam production sthapatya gRPC ko firewall ke pichhe seva-se-seva sanchaar ke liye upyog karti hai, ek GraphQL gateway ko prakat karti hai jo kai gRPC sewaon ka data ekatrit karta hai, aur bahari clients ke liye REST API pradan karti hai. Sawaal yah nahi hai ki kaun sa protocol har jagah upyog karein — yah hai ki aapke pranali ke pratyek interfeys ke liye kaun sa protocol upyog karein. Pratyek ke pichhe dizain philosophy ko samajhna aapko vah nirnay sahi karne ki kshamata deta hai.