Rivya API är utvecklarvägen för att använda Rivyas modellförmågor från din egen produkt, ditt script eller ditt arbetsflöde.
Det är inte en separat produkt från Rivya Studio. Det använder samma kontogräns, samma kreditplånbok och samma publika modellager som användare ser i Rivya. Skillnaden är hur arbetet startar: i stället för att klicka genom Studio skickar din applikation begäranden med en API-nyckel.
Om du behöver endpointdetaljer, börja med Rivya API-översikt och Rivya API-snabbstart. Den här artikeln är förklaringen på produktnivå: vad API:et är till för, var det passar och när det inte bör vara första vägen.
Den korta versionen
Rivya API v1 låter ett inloggat konto skapa API-nycklar och anropa Rivyas modellförmågor utanför webbgränssnittet.
Den aktuella API-ytan innehåller:
- modellupptäckt genom API-modellistan
- asynkrona genereringsjobb för bild, video och ljud
- Files API-uppladdningar för modeller som behöver referensmedia
- polling av genereringsstatus med publika uppgifts-ID:n
- kontroller av kontocredits
- Chat API-turer, inklusive valfri SSE-streaming
- signerade webhooks för slutförd generering
- en TypeScript SDK-beta för team som vill ha en klientwrapper
Den publika utvecklarhubben är Utvecklare. Den är bästa ingången om du vill ha en guidad översikt, länkar till API-nyckelinställningar och ett säkert felsökningsflöde.
Varför Rivya har ett API
Studio är användbart när en person fortfarande väljer modeller, formar prompter, granskar resultat och bestämmer vad som ska hända härnäst.
API:et är användbart när det beslutet har blivit en upprepbar produkt eller ett operativt arbetsflöde.
Vanliga exempel:
- en produkt vill generera bildvarianter efter att en användare skickar in en brief
- ett marknadsföringsarbetsflöde behöver skapa visuella utkast från strukturerade kampanjindata
- ett internt verktyg behöver skicka video- eller audiojobb utan att be någon öppna webbläsaren
- ett support- eller contentsystem vill ha en chatmodellturn i sitt eget gränssnitt
- en backendtjänst vill ha signerade callbacks när genereringsjobb är klara
I de fallen håller Rivya API arbetet kopplat till samma Rivya-konto i stället för att tvinga fram en separat stack för fakturering, modellval och uppgiftsstatus.
Vad API:et inte ersätter
API:et ersätter inte alla skäl att använda Rivya direkt.
Använd Studio eller de publika arbetsytorna när:
- prompten fortfarande behöver mänsklig utforskning
- modellvalet inte är stabilt
- en kreatör behöver jämföra resultat visuellt
- projektet beror på sparad historik och manuell granskning
- teamet inte har bestämt vilket indata- och resultatformat som ska bli upprepbart
Använd API:et när arbetsflödet är tillräckligt tydligt för att automatiseras.
Den gränsen spelar roll. En vag kreativ fråga hör oftast hemma i Studio först. Ett känt produktflöde med förutsägbara indata kan flytta till API:et.
De viktigaste byggblocken
Tänk på API:et som sex sammankopplade delar.
| Byggblock | Vad det hanterar | Läs vidare här |
|---|---|---|
| API-nycklar | Server-till-server-åtkomst från ditt konto | API-autentisering |
| Modeller | Publika modell-ID:n och tillgänglighetsinformation | API-modeller |
| Genereringar | Asynkrona bild-, video- och ljudjobb | Skapa generering |
| Files | Uppladdningar av referensbild, video eller audio | Files API |
| Chatt | Icke-streamade eller streamade chatturns | Chat API |
| Webhooks | Signerade slutförandehändelser för genereringsjobb | API Webhooks |
API-dokumentationen är källan för formatet för begäran och svar. Den här artikeln ska hjälpa dig att avgöra vilken del du behöver först.
Hur credits fungerar
API-användning drar från samma Rivya-kontoplånbok för credits som Studio.
Det betyder att API:et inte är en anonym modellproxy. En begäran hör till ett Rivya-konto, använder en API-nyckel skapad av det kontot och följer samma produktnivågräns för krediter som beskrivs i API Credits.
Det är användbart för team eftersom Studio-experiment och API-användning stannar i en och samma operativa modell. Du kan testa en modell manuellt och sedan flytta den upprepbara delen till en integration utan att skapa ett andra faktureringslager.
Hur filer passar in
Vissa modeller kan köras från enbart text. Andra behöver en referensbild, video eller ljudfil.
För API-integrationer bör dessa referenser gå genom Files API. Uppladdningen skapar en hanterad filpost som kan skickas in i stödda modellparametrar.
Den praktiska regeln är enkel:
- om en modell accepterar enbart textindata, börja med genererings-endpointen
- om en modell behöver referensmedia, ladda upp filen först
- om modellen är en chattmodell med bildbilagor, använd Chat API och fil-ID:n
Designa inte integrationen runt uppladdningsflöden som bara fungerar i webbläsaren eller sparade Studio-sessioner. API:et har en egen publik filgräns av en anledning.
Där webhooks hjälper
Polling är den enklaste första integrationsvägen. Skicka ett genereringsjobb, spara det publika uppgift ID:t och polla tills det lyckas eller misslyckas.
Webhooks blir användbara när integrationen är mer produktionslik:
- du vill inte ha en arbetare som pollar varje jobb
- din app behöver uppdatera en post när genereringen är klar
- du vill ha en signerad händelse som kan försöka igen säkert
- misslyckade jobb behöver flytta till en tydlig återställningsväg
För kontraktet för signerade händelser, använd API Webhooks. Håll webhook-mottagaren smal: verifiera signaturer, hantera dubbletthändelser och undvik att lägga hemliga värden i loggar.
Ett bra första API-projekt
Det bästa första API-projektet är oftast litet och konkret.
Till exempel:
- skapa en API-nyckel i inställningar
- anropa modellistan
- välj en tillgänglig modell
- skicka ett genereringsjobb med en idempotensnyckel
- polla status-endpointen
- kontrollera krediter före och efter
- lägg först därefter till Files API, Chat API eller Webhooks
Den vägen ger dig en fungerande integration utan att blanda in varje API-funktion i första testet.
När API:et är fel startpunkt
API:et är troligen inte rätt första steg när:
- teamet ännu inte har valt en modellfamilj
- önskad resultat fortfarande ändras vid varje körning
- prompten beror på manuell smak och granskning
- integrationen skulle dölja kreditanvändning för personerna som behöver förstå den
- produkten behöver en publik demo innan den behöver automatisering
I de fallen, börja från Image, Video, Audio, Chat eller AI Models. När vägen är upprepbar flyttar du den stabila delen till API:et.
Vart du går härnäst
- Öppna Utvecklare för den publika API-hubben och felsökaren.
- Läs Rivya API-snabbstart för att göra den första säkra begäran.
- Läs API-autentisering innan du lägger en nyckel på en server.
- Läs API-modeller innan du väljer modell-ID:n.
- Läs När du ska använda Rivya API i stället för Studio om produktgränsen fortfarande är oklar.
- Läs Så bygger du ett multimodalt AI-arbetsflöde med Rivya API när du planerar en full bild-, video-, ljud- eller chattintegration.
