> A Replicate több ezer nyílt modellt tesz egyetlen predikciós API mögé, és a számítási idő másodpercével számol. Teszt a cold bootokról, verziódriftről és az egy órás törlésről.
>
> Web page: https://balazscsorba.com/hu/blog/replicate · Language: Magyar · Also available in: [English](https://balazscsorba.com/blog/replicate.md) · [Deutsch](https://balazscsorba.com/de/blog/replicate.md)
> Author: Balázs Csorba · Published: 2026-05-22 · Keywords: replicate api, replicate vs fal.ai, serverless gpu inference pricing, replicate webhooks, replicate cold start, replicate vs baseten, how to run an open source model in production, replicate prediction api

[Blog](https://balazscsorba.com/hu/blog)/Webfejlesztés

# Replicate teszt: modell-API másodpercenkénti árazással, az élekkel együtt

A Replicate több ezer nyílt modellt tesz egyetlen predikciós API mögé, és a számítási idő másodpercével számol. Teszt a cold bootokról, verziódriftről és az egy órás törlésről.

[Balázs Csorba](https://balazscsorba.com/hu/about)·2026\. május 22.·10 perc olvasás

-   Model hosting
-   Serverless GPU
-   Diffusion
-   Async jobs
-   Webhooks

![Csúszda széles tálca felett, három kis négyzet különböző magasságban, kör az időre.](https://balazscsorba.com/images/blog/replicate/cover.webp?v=f807899e8c)

## A lényeg röviden

-   A Replicate a nyilvános katalógus modelljeit hardveridő-másodpercben méri, és nem fizet, amíg egy megosztott modell áll. Ez olcsó az ingadozó terhelésre, drága mindenre, ahol a késleltetés számít.
-   Minden futás egy predikciós objektum fix állapotokkal, és a canceled és az aborted közötti különbség dönti el, fizetsz-e a lefutott számításért.
-   Az API-n létrehozott predikciók egy óra után törlődnek, a bemenetekkel és kimenetekkel együtt, így minden, amire szükség van, előtte ki kell másolni.
-   Csak a hivatalos modelleknek stabil az input-sémájuk. A közösségi modelleket a szerzőik tartják karban, ezekhez rögzített verzió és teszt kell.
-   A deployment rögzít egy verziót hardverre és példánytartományra. Ez megszünteti a cold bootokat, és helyettük fix óradíj marad.

Ezen az oldalon

1.  [Mi a Replicate valójában](https://balazscsorba.com/#what-it-is)
2.  [Hogyan fut egy predikció](https://balazscsorba.com/#how-it-works)
3.  [Első lépések](https://balazscsorba.com/#getting-started)
4.  [Mennyibe kerül](https://balazscsorba.com/#pricing)
5.  [Adatmegőrzés, tokenek és webhookok](https://balazscsorba.com/#security-and-data)
6.  [Hol fáj](https://balazscsorba.com/#where-it-shingles)
7.  [Verdiktrum](https://balazscsorba.com/#verdict)
8.  [Források](https://balazscsorba.com/#sources)

Cikk meghallgatása

0:000:00

A Replicate mennyezetes inferenciaplatform, amely több ezer nyílt súlyú és proprietáris modellt fog össze egyetlen predikciós API mögött, és csak azokra a másodpercekre számol, amíg egy gép tényleg futtatja a kérésed. Az álláspont egyszerű: annak a csapatnak, amely ma délután ki akarja próbálni egy új kép- vagy videomodellt anélkül, hogy GPU-t kellene beállítania, ez a legrövidebb út a piacon. Azoknak a terméknek, amelynek késleltetési kerete és kiszámítható számlája van, a másodpercenkénti árazás rossz szerződés, és a platform csak akkor védhető, ha a verzió rögzített, és a modell deploymenten fut.

Valahol a saját GPU és a modellbeszállító között helyezkedik el. Az egyik oldalon versenytársa a [fal.ai](https://fal.ai/pricing) és a [Baseten](https://www.baseten.co/pricing/), amelyek inferenciát adnak el katalógus helyett; a másikon a GPU-közvetítőtől bérelt gép és a saját konténer. Amit nem vált fel, az a tokenenként számolt LLM-API. A Replicate szívesen szolgálja ki egy Llama modellt egy H100-on, de senki nem áraz egy chat-végpontot másodpercenkénti GPU-időre.

## Mi a Replicate valójában

Három dolog oszt egy fiókot és egy API-t. Először a szerzőik által közzétett modellek nyilvános katalógusa: finomhangolások, közösségi implementációk, kutatási kód. Másodszor a hivatalos modellek halmaza, amelyeket maga a Replicate tart karban, a dokumentáció szerint több mint százat, amelyek mindig melegen állnak, kimeneti egységenként áraznak, és stabil input-sémájuk van. Harmadszor azok a privát modellek, amelyeket magad csomagolsz Cog-gal, és dedikált hardveren futtatod, ahol az példány teljes életidejéért fizetsz, nem az elvégzett munkáért.

-   Minden futás egy predikciós objektum, benne bemenetek, kimenetek, állapot, időzítési metrikák és cancel URL, bármit is csinál a modell.
-   Másodpercenkénti árazás a közzétett díjakkal: 0,000025 $ egy kis CPU-ra, 0,000225 $ egy T4-re, 0,001400 $ egy 80 GB A100-ra, 0,001525 $ egy H100-ra.
-   A hivatalos modellek kimenet szerint számolnak: flux-1.1-pro 0,04 $ képpenként, ideogram-v3-quality 0,09 $, deepseek-r1 3,75 $ millió input tokenre.
-   `Aszinkron` az alapértelmezés; szinkron a `Prefer: wait` headerrel lesz, ami 60 másodpercig tartja nyitva a kérést.
-   Előleg, nem előfizetés. A kredit egy évig érvényes a vásárlástól, és nem visszatéríthető.
-   Apache-2.0 kliens Node.jshez, Pythonhoz, Swifthez és Go-hoz, plusz a mcp.replicate.com hosztolt MCP-szervere, ami követi a HTTP API-t.

## Hogyan fut egy predikció

Egy predikció létrehozása azonnal visszaad egy objektumot `starting` állapottal, és ez az objektum marad a munkaegység a futás idejére. Három dönti el, majd meddig vársz: hogy a modell meleg-e, mennyi ideig fut maga a modell, és hogy pollolsz, nyitva tartod a HTTP kapcsolatot, vagy egy webhookra vársz.

![A Replicate predikciós életciklusa Egy predikció létrejön, a starting állapotból processingbe lép. A processing három végállapot egyikében ér véget: succeeded, canceled ha a határidő a futás közben lejárt, vagy failed. Ha a határidő a kezdés előtt jár le, a predikció aborted állapotban végződik, ami nem számítódik.](https://balazscsorba.com/images/blog/replicate/diagram-7.webp?v=80d4a2b6c9)

Egy predikció létrejön, elindul, fut, majd négy végállapot egyikében ér véget. A költség szempontjából a különbség a canceled és az aborted között döntő: az előbbi a futás idejéig számít, az utóbbi semmit.

Az állapotok kevesek, és a működési információt hordozzák. A `starting` normálisan jóval egy másodpercnél rövidebb; ha tovább tart, az cold boot, és több gigabájt súly betöltése több percet is vehet. A `processing` a modell saját `predict()` metódusa. Utána a `succeeded`, `failed`, `canceled` vagy `aborted` állapot zárja a futást, és az utóbbi kettő közötti különbség az, hogy a gép elindult-e egyáltalán.

A predikciók 30 perc után timeoutba ütköznek, és a predikcióhoz megadott határidő lehetővé teszi, hogy az alkalmazás hamarabb feladja. A számlázási szabály pontosan követi ezt a kettősséget: a kezdés előtt megszakított predikció nem számítódik, az utána megszakított a futott másodpercekért. Ez valóban jó tervezés, és egyben az egyetlen ok, hogy a határidőt bátran szigorúan lehet állítani.

## Első lépések

A Node.js kliens az életciklust a `run()` hívásba zsugorítja. Egy olyan modellnél, amely másodpercek alatt végez, ez a teljes integráció, mást nem is kell írni.

```
import Replicate from "replicate";
import { writeFile } from "node:fs/promises";

// Reads REPLICATE_API_TOKEN from the environment.
const replicate = new Replicate();

const [image] = await replicate.run("black-forest-labs/flux-schnell", {
  input: {
    prompt: "An astronaut riding a rainbow unicorn, cinematic lighting",
  },
});

await writeFile("output.png", image);
console.log("saved output.png");
```

A hosszabb modellekhez az aszinkron út kell, és az eredményről csak egy webhook értesít hitelesen. Két részlet szokott hibát okozni. Az aláírás a nyers kérés törzsét fedi le, ezért az ellenőrzésnek minden JSON-feldolgozás előtt kell futnia. A kliens pedig a HMAC kiszámítása előtt visszaalakítja a bájttörzset sztringgé, ami csendben minden aláírásellenőrzést törne.

```
import express from "express";
import Replicate from "replicate";
import { createHmac, timingSafeEqual } from "node:crypto";

const replicate = new Replicate();
const app = express();

// Verify first, parse second: the signature covers the raw body bytes.
app.post("/webhook", express.raw({ type: "application/json" }), (req, res) => {
  const key = process.env.REPLICATE_WEBHOOK_KEY.replace("whsec_", "");
  const signed = `${req.headers["webhook-id"]}.${req.headers["webhook-timestamp"]}.${req.body}`;
  const expected = createHmac("sha256", key).update(signed).digest("base64");
  const seen = String(req.headers["webhook-signature"]).split(" ").map((p) => p.split(",")[1]);
  const valid = seen.some((sig) => {
    const a = Buffer.from(sig), b = Buffer.from(expected);
    return a.length === b.length && timingSafeEqual(a, b);
  });
  if (!valid) return res.status(401).end();

  const prediction = JSON.parse(String(req.body));
  res.sendStatus(204); // Replicate retries terminal webhooks on 4xx and 5xx.
  console.log(prediction.id, prediction.status);
});

app.post("/image", async (req, res) => {
  const prediction = await replicate.predictions.create({
    model: "black-forest-labs/flux-schnell",
    input: { prompt: req.body.prompt },
    webhook: "https://example.com/webhook",
    webhook_events_filter: ["completed"],
  });
  res.json({ id: prediction.id });
});
```

**A nyitva tartott kapcsolat a legolcsóbb és a legrosszabb integráció**

`Prefer: wait` alapértelmezés szerint 60 másodpercig tartja nyitva a kérést, és a header értéket fogad, tehát a `Prefer: wait=5` rövidebb keretet ad. Utána a válasz `starting` vagy `processing` állapottal érkezik, és úgyis pollolni kell.

## Mennyibe kerül

A nyilvános katalógus másodpercenként méri a számítási időt, és az ár a hardverhez tartozik, nem a modellhez. A közzétett táblázat óradíjat is számít ki minden arányhoz, ami az összehasonlításhoz jó, de nem ezt számítják. A megosztott kapacitáson az indítási és az üresjárati idő ingyenes, csak a feldolgozás számít.

Hardver

Másodperc

Óra

Memória

`cpu-small`

0,000025 $

0,09 $

2 GB RAM, 1 vCPU

`cpu`

0,000100 $

0,36 $

8 GB RAM, 4 vCPU

Nvidia T4

0,000225 $

0,81 $

16 GB VRAM

Nvidia L40S

0,000975 $

3,51 $

48 GB VRAM

Nvidia A100 80 GB

0,001400 $

5,04 $

80 GB VRAM

Nvidia H100

0,001525 $

5,49 $

80 GB VRAM

A hivatalos modellek megtörik ezt a mintát, és innen lesz kiszámítható a számla. A flux-1.1-pro 0,04 $ kimeneti képenként, a flux-schnell 3,00 $ ezer képenként, az ideogram-v3-quality 0,09 $, a deepseek-r1 pedig tokenenként. Minden privát modell visszafordítja ezt: dedikált hardveren fut, és az indítási, az üresjárati és az aktív időért egyaránt fizetsz, tehát egy példány akkor is pénzbe kerül, ha egész délután senki nem hívja.

Előre fizetsz. A hitelt előre vásárolod, a használat levon belőle, egy évig érvényes, és nem visszatéríthető. Ha az egyenleg nulla, a futó infrastruktúrát lekapcsolják, és új munka nem indul. Az a predikció, amely túllépi a hitelet, a hónap végén a megadott fizetési eszközből számítanak le. Van automatikus feltöltés, a dokumentált minimum 5 $ küszöb és 15 $ feltöltés, és ez a legolcsóbb védelem a megfojtott kérések sora ellen.

### Deploymentek és cold bootok

Egy deployment egy modellverziót rögzít egy hardvertípushoz és egy példánytartományhoz, és egyszerre válaszol a cold boot és az üresjárati költség kérdésére. Az ár nyílt: egy melegen tartott T4 0,81 $ óránként, vagyis 583 $ egy harmincnapos hónapban, amely sosem üresjárat, szemben a nullával ugyanerre a modellre, ha napi száz hívás fut rajta megosztott kapacitáson. A deployment itt megszűnik rugalmas lenni, és a belső költségtétel lesz.

-   Rögzítsd a tesztelt verziót. Egy új modellverzió így nem változtathatja meg a viselkedést terhelés alatt.
-   Állítsd `min_instances` értékét 1-re, és a cold boot, a többperces súlybetöltéssel együtt, megszűnik.
-   A dedikált hardver nem jelent várakozó sor más felhasználóktól, de minden üresjárati órát fizetni kell.
-   Ugyanez a hasadás választja el a hivatalos modelleket, amelyeket a Replicate tart karban és melegen tart, a közösségi modellektől, amelyeket a szerzőik tartanak, és amelyek hidegen indulhatnak.

## Adatmegőrzés, tokenek és webhookok

Az API-n átmenő minden alapértelmezés szerint illékony. Az API-n létrehozott predikcióknál a dokumentáció szerint a bemeneti paramétereket, a kimeneti értékeket, a kimeneti fájlokat és a logokat egy óra után eltávolítják, és saját másolatot kell tartani. A webes felületen létrehozott predikciók viszont korlátlan ideig megmaradnak. Ez az aszimmetria a dokumentáció legmeglepőbb működési ténye, mert ugyanaz a modell két nagyon különböző megőrzési szabály alá kerülhet attól függően, melyik felületet használták.

-   Az API-tokenek 40 karakteres, `r8_` előtagú stringek, bearer tokenként mennek, környezetenként nevezhetők, és egyenként visszavonhatók.
-   A Replicate átnézi a nyilvános repókat a kiszivárgott tokenek után, és az kompromittáltakat automatikusan letiltja, magyarázó e-maillel. Kényelmes, de egyben olyan út is, amelyen egy téves riasztás megállítja a produkciót.
-   A webhookok hordoznak `webhook-id`, `webhook-timestamp` és `webhook-signature` mezőt; a hitelesített tartalom a pontokkal összefűzött három, HMAC-SHA256 aláírással.
-   Az aláírási kulcs a `GET /v1/webhooks/default/secret` végpontjáról jön, és a dokumentáció cache-elést javasol neki kiszolgálásonkénti lekérés helyett.
-   A limitek 600 predikciólétrehozás percenként és 3000 kérés percenként minden más végponton, 429-es választesttel, amely megnevezi az újraengedélyezési ablakot.

**Először a webhook-kezelő legyen idempotens**

A terminális webhookokat exponenciális visszacsúszással ismétli, az utolsó próbálkozás körülbelül egy perccel a befejezés után, és a dokumentáció szerint ugyanaz a webhook többször is érkezhet, a sorrend pedig nem garantált. Az a kezelő, amely exactly-once-ra épít, vagy elveszít, vagy dupláz munkát. Kulcsolj a `prediction.id` mezőre, és mindent hagyj figyelmen kívül, ami végállapot után érkezik.

## Hol fáj

A katalógus a termék, és a katalógus a kockázat. Egy közösségi modell egy idegen által közzétett konténer: az input-séma verziók között megváltozhat, a szerzője eltűnhet, és maga a Replicate dokumentációja szerint a közösségi modelleknél eltérő lehet a stabilitás, a dokumentáció és a támogatás szintje. Csak a hivatalos modelleknek van stabil API-juk, és amit a vevő lát, annál a rögzített verzió és egy teszt a minimum.

Dimenzió

Replicate

fal.ai

Baseten

Számlázási egység

Számítási másodperc; hivatalos modellek kimenet szerint

Másodperc, kép vagy 1000 token szerint

1 millió token vagy GPU-óra szerint

Katalógus

Több ezer közösségi és hivatalos modell

Kis, kurált optimalizált modellkészlet

Főként azok a modellek, amiket te deployolsz

Saját modell

Cog-konténer, nyilvános vagy privát

Deploymentek a fal GPU-flottáján

Dedikált deploymentek; VPC és saját hosztolás a legfelső szinten

Serverless GPU-arány

Nincs bérleti pool, csak másodperces díjak

H100 2,49 $ óránként saját deploymenten

Deploymentenként kérendő

A második probléma, hogy a számla soha nem az a számla, amit a pénzügy vár. Egy 0,04 $ a képpenkénti és egy 5,49 $ óránkénti modell is egy oda nem figyelő ciklus mögé kerülhet, és az egyetlen futásszintű adat, amit az API visszaad, az egy adott predikció `metrics` objektuma, amit alapból senki nem aggregál.

Harmadszor, a klienskönyvtárak egyenetlenek. A Node.js kliens 1.4.0-nál, a Python kliens 1.0.7-nél jár, a 2.0 sorozat pedig beta helyett kiadásra vár. Egy Python szolgáltatásnak közvetlenül a HTTP API-t érdemes hívnia várakozás helyett, és ezt az OpenAPI séma meg a llms.txt végpont kellemetlen egyszerűvé teszi.

## Verdiktrum

A Replicate a legjobb ár-érték egyetlen konkrét problémára: nyílt modellt futtatni GPU nélkül. Minden másra rosszul illeszkedik, és ennek oka strukturális, nem érettségi. A másodpercenkénti árazás a szolgáltató hardverkihasználását optimalizálja, és a te számlád ennek az optimalizálásnak a zajterme.

1.  Csapatok, amelyek egy új kép-, videó- vagy beszédmodellt prototipizálnak, és erre a hétre választ akarnak.
2.  Csapatok, amelyek hajlandók rögzíteni egy verziót, stabilan tartani az input-sémát, és az egészet egy merev költségkeretbe zárni.
3.  Mindenki, aki modellnagyobbonságot akar egy platform helyett, és elfogadja, hogy a katalógus nagy része karbantartás nélkül marad.
4.  Ne válaszd interaktív végponthoz, ahol a farok-késleltetés termékfeltétel, és ne egyenletes, néhány százalékos kihasználás feletti terheléshez, ahol egy fenntartott GPU egyszerűen olcsóbb.
5.  Ne válaszd, ha a bemeneti fájlok védett személyes adatot tartalmaznak, és az egyórás megőrzési ablak nem felel meg a saját előírásaidnak.

A katalógus szupermarket, a deployment pedig gépbérlet. Annak eldöntése, hogy melyikre építesz, a munka nagyobb része, és az API nem fogja meghozzni helyetted ezt a döntést.

## Források

1.  [Replicate pricing](https://replicate.com/pricing)
2.  [Replicate docs: About predictions](https://replicate.com/docs/topics/predictions)
3.  [Replicate docs: Create a prediction](https://replicate.com/docs/topics/predictions/create-a-prediction)
4.  [Replicate docs: Prediction lifecycle](https://replicate.com/docs/topics/predictions/lifecycle)
5.  [Replicate docs: Rate limits](https://replicate.com/docs/topics/predictions/rate-limits)
6.  [Replicate docs: Data retention](https://replicate.com/docs/topics/predictions/data-retention)
7.  [Replicate docs: Verify webhooks](https://replicate.com/docs/topics/webhooks/verify-webhook)
8.  [Replicate docs: Official models](https://replicate.com/docs/topics/models/official-models)
9.  [fal.ai pricing](https://fal.ai/pricing)
10.  [Baseten pricing](https://www.baseten.co/pricing/)

## Gyakori kérdések

Valójában miért fizet a Replicate?

A nyilvános katalógus modelljeiért a futtatott hardver másodpercenkénti díját, ami egy kis CPU-nál 0,000025 $ és egy H100-nál 0,001525 $. A hivatalos modellek a kivételek: kimeneti képenként, videó másodpercenként vagy tokenenként számolnak. A privát modellek dedikált hardveren futnak, így az indítási és az üresjárati időért is fizetsz.

Olcsóbb-e a Replicate, mint GPU-t bérelni?

Az ingadozó, kis terhelésű munkáknál igen, mert csak a futás idejéért fizetsz, és a kapacitás megoszlik a felhasználók között. Néhány százalékos, egyenletes terhelés felett fordítva jár a kép: egy melegen tartott T4 példány 0,81 $ óránként, ami egy harmincnapos, soha nem üresjárati hónapban 583 $. Onnantól a RunPod vagy a Lambda fenntartott példánya a kedvezőbb szerződés.

Miért tart percekig a Replicate predikció, mielőtt elindul?

Ez cold boot. A Replicate lekapcsolja a nem használt modelleket, az újraindítás pedig több gigabájt súly betöltésével jár, ami a dokumentáció szerint több percet is tarthat. A hivatalos modellek melegen maradnak, a deployment pedig min\_instances érték 1 mellett megszünteti a várakozást mindenk másnál.

Megtartja a Replicate a bemeneteket és a kimeneteket?

API-predikcióknál nem. A bemeneti paramétereket, a kimeneti értékeket, a kimeneti fájlokat és a logokat egy órával a létrehozás után törli, a dokumentáció szerint saját másolatot kell tartani. A webes felületről indított predikciók viszont korlátlan ideig megmaradnak, ami számít, ha ugyanazt a modellt mindkét úton használod.

Írta: Csorba Balázs

Senior fullstack és AI mérnök Stájerországban – több mint 10 év Vue, Nuxt, Node.js és PHP, ma AI-ügynököknek építek eszközöket.

[AI fejlesztés és MCP szerverek →](https://balazscsorba.com/hu/expertise/ai-engineer)[Rólam →](https://balazscsorba.com/hu/about)

## További cikkek

-   [Schema.org strukturált adatok B2B webshopokhoz: bejelentkezés mögötti árak, egységek és változatok](https://balazscsorba.com/hu/blog/schema-org-structured-data-b2b-shop)
-   [AI-asszisztens a B2B webshop ügyfélszolgálatához: eszközök, jogosultságok és átadás embernek](https://balazscsorba.com/hu/blog/ai-assistant-b2b-shop-customer-support)
-   [AI-csevegő UI Vue-ban és Nuxtban: akadálymentes streaming](https://balazscsorba.com/hu/blog/vue-ai-chat-ui-streaming-accessibility)
-   [LLM-fordítási pipeline i18n-hez: glosszárium, helyőrzők és review](https://balazscsorba.com/hu/blog/llm-translation-pipeline-i18n)

## Pont erre van szükséged?

Írj a projektedről vagy a pozícióról – szívesen hallok felőled.

[Lépj velem kapcsolatba](mailto:contact@balazscsorba.com) [Kapcsolódjunk LinkedInen](https://www.linkedin.com/in/balazs-csorba)