Przejdź do treści
Sklep

Narzędzia

API wideo AI: status zadania i bezpieczne ponawianie bez podwójnych opłat

Generowanie wideo przez API trwa od kilkudziesięciu sekund do kilku minut, dlatego odbywa się asynchronicznie. Zobacz, jak zbudować bezpieczną pętlę odpytującą o status zadania i nie wysłać płatnego żądania POST dwa razy po błędzie sieci.

Tekst: 12 min czytania
API wideo AI: status zadania i bezpieczne ponawianie bez podwójnych opłat
Spis treści 10
  1. Dlaczego generowanie wideo przez API jest asynchroniczne
  2. Katalog modeli wideo i koszt pojedynczego wywołania POST
  3. Cykl życia zadania wideo: od zlecenia do wyniku
  4. Pułapka ponawiania POST vs bezpieczeństwo GET
  5. Wzorzec bezpiecznego przepływu pracy (krok po kroku)
  6. Przykładowy kod w Pythonie (ilustracyjny wzorzec obsługi zadań)
  7. Jak reagować na poszczególne kody HTTP
  8. Aspekty rozliczeniowe i organizacyjne w firmie
  9. Najczęściej zadawane pytania (FAQ)
  10. Źródła

👁 119 przeczytań

w skrócie
  • Aby uniknąć podwójnych opłat, należy wyłączyć automatyczne retry dla metody POST /v1/generate i zapisywać identyfikator zadania natychmiast po jego odebraniu.
  • Przypadkowe trzykrotne wysłanie żądania dla Seedance 2.5 w 1080p (5 s) podnosi koszt z 40,76 zł do 122,29 zł, a dla Veo 3.1 Quality w 4K - z 21,88 zł do 65,64 zł.
  • Metoda GET /v1/tasks/{id} jest bezpieczna i idempotentna, więc wielokrotne odpytywanie o status zadania nie nalicza żadnych dodatkowych opłat.

Generowanie wideo za pomocą modeli sztucznej inteligencji nie mieści się w czasie pojedynczego, synchronicznego żądania HTTP. Podczas gdy odpowiedź czatu tekstowego wraca w ułamku sekundy, wyrenderowanie kilkusekundowego klipu w rozdzielczości 1080p lub 4K wymaga pracy klastra GPU przez kilkadziesiąt sekund lub kilka minut. Z tego powodu komunikacja z API wideo odbywa się w modelu asynchronicznym: najpierw zlecasz zadanie (POST), odbierasz jego identyfikator, a następnie cyklicznie sprawdzasz postęp (GET). Największym błędem w kodzie klienckim jest automatyczne ponawianie żądania tworzącego zadanie w sytuacji, gdy połączenie zostanie zerwane tuż po przyjęciu zlecenia przez serwer. Taki błąd potrafi pomnożyć koszt wideo kilkukrotnie. Poniżej pokazuję, jak poprawnie zaprojektować obsługę cyklu życia zadania i zabezpieczyć skrypt przed duplikatami.

Dlaczego generowanie wideo przez API jest asynchroniczne

Standardowe serwery HTTP, bramki sieciowe i biblioteki klienckie mają domyślne limity czasu oczekiwania na odpowiedź (tzw. timeout), zazwyczaj ustawione na 30, 60 lub 120 sekund. Gdyby punkt końcowy odpowiedzialny za generowanie multimediów trzymał otwarte połączenie przez cały czas renderowania klatek, duża część żądań kończyłaby się błędem sieciowym po stronie klienta, mimo że proces na serwerze nadal by trwał.

Rozdzielenie zlecenia od odbioru wyniku rozwiązuje ten problem. W moim serwisie (Jantaris) obsługa multimediów - zarówno obrazu, wideo, jak i audio - opiera się na dwóch punktach końcowych opisanych w dokumentacji API:

  • POST /v1/generate - przyjmuje parametry modelu, blokuje wymaganą kwotę na saldzie i natychmiast zwraca identyfikator zadania oraz szacowany koszt w polu estimated_cost.
  • GET /v1/tasks/{id} - służy do lekkiego odpytywania (pollingu) o aktualny stan zadania aż do momentu, gdy plik wideo będzie gotowy do pobrania lub proces zakończy się błędem.

Katalog modeli wideo i koszt pojedynczego wywołania POST

Zrozumienie mechanizmu ponawiania warto zacząć od spojrzenia na stawki, ponieważ każde nadmiarowe wywołanie POST /v1/generate to osobna blokada środków na koncie. W dniu 24.10.2026 wykonałem rzeczywiste zapytanie GET https://jantaris.com/v1/models?currency=PLN, które zwróciło kod HTTP 200 oraz listę 85 obiektów modeli.

Poniżej znajduje się dokładny wycinek rzeczywistej odpowiedzi JSON z tego odczytu dla dwóch modeli wideo - jednego rozliczanego za sekundę (Seedance 2.5) oraz jednego rozliczanego za cały wygenerowany plik (Veo 3.1 Quality):

[
  {
    "id": "seedance-2.5",
    "name": "Seedance 2.5",
    "category": "video",
    "available": true,
    "pricing": {
      "unit": "second",
      "amount": "3.38452",
      "currency": "PLN",
      "display": "3,38 zł / second",
      "variants": [
        {"resolution": "480p", "amount": "1.50424"},
        {"resolution": "720p", "amount": "3.38452"},
        {"resolution": "1080p", "amount": "8.15294"}
      ],
      "vat_included": true
    }
  },
  {
    "id": "veo-3.1",
    "name": "Veo 3.1 (Quality)",
    "category": "video",
    "available": true,
    "pricing": {
      "unit": "video",
      "amount": "14.58713",
      "currency": "PLN",
      "display": "14,59 zł / video",
      "variants": [
        {"resolution": "720p", "amount": "14.58713"},
        {"resolution": "1080p", "amount": "14.58713"},
        {"resolution": "4k", "amount": "21.88069"}
      ],
      "vat_included": true
    }
  }
]

Obecność modelu w katalogu z flagą "available": true oznacza jego dostępność w ofercie na moment odczytu (w aktualnym katalogu z 24.10.2026 dostępny jest także m.in. model obrazowy Seedream 5.0 Flash w cenie 0,201 zł / image, natomiast nie ma w nim modeli Kling 4 ani Kimi K3.1 Pro). Sam odczyt katalogu nie jest oczywiście równoznaczny z pomiarem czasu renderowania konkretnego pliku.

Aby zobrazować skalę kosztów przy przypadkowym zduplikowaniu żądania, wykonajmy prosty, lokalny rachunek arytmetyczny na podstawie dokładnych pól amount z powyższego zrzutu katalogu (bez uruchamiania płatnej generacji):

  • Seedance 2.5 w 1080p (5 sekund): stawka wynosi 8.15294 zł brutto za sekundę. Pojedyncze zlecenie 5-sekundowego klipu to 5 * 8.15294 zł = 40,7647 zł (w zaokrągleniu 40,76 zł brutto). Jeśli skrypt po błędzie sieci wyśle POST trzy razy, koszt wzrośnie do 122,2941 zł.
  • Veo 3.1 (Quality) w 4K: stawka za jeden plik wideo w wariancie 4K to 21.88069 zł brutto. Trzykrotne wysłanie tego samego żądania przez źle skonfigurowaną pętlę retry zablokuje 3 * 21.88069 zł = 65,64207 zł (ok. 65,64 zł brutto).
Model wideo (ID w API)Jednostka rozliczeniowaCena katalogowa brutto (720p / 1080p)Koszt 5 s (lub 1 wideo) w 1080p
grok-imagine-1.0-videosecond0,30443 zł / brak wariantu 1080p (480p: 0,17251 zł)1,52 zł (dla 720p)
pixverse-v6second0,46679 zł / 0,93358 zł4,67 zł
kling-3.0second0,5447 zł / 0,70033 zł3,50 zł
vidu-q3-turbosecond0,70018 zł / 0,81688 zł4,08 zł
wan-3.0second0,89584 zł / 1,79178 zł8,96 zł
seedance-2.0second1,95024 zł / 4,85181 zł24,26 zł
seedance-2.5second3,38452 zł / 8,15294 zł40,76 zł
veo-3.1-fastvideo2,0422 zł / 2,0422 zł2,04 zł (za plik)
veo-3.1video14,58713 zł / 14,58713 zł14,59 zł (za plik)

Pełne zestawienie wszystkich 85 modeli oraz ich wariantów rozdzielczości można sprawdzić w aktualnym cenniku. Szersze omówienie różnic między stawkami za sekundę w poszczególnych rodzinach znajduje się w tekście o API do generowania wideo i cenach za sekundę oraz w osobnych artykułach o parametrach Kling 3.0 przez API i modelach Seedance 2.5 i 2.0.

Cykl życia zadania wideo: od zlecenia do wyniku

Typowy przepływ pracy z asynchronicznym API multimedialnym składa się z czterech etapów:

  1. Zlecenie (POST /v1/generate): Klient wysyła nazwę modelu, prompt oraz parametry (np. czas trwania, rozdzielczość). Serwer weryfikuje saldo, blokuje kwotę odpowiadającą estimated_cost i zwraca identyfikator zadania.
  2. Oczekiwanie w kolejce i przetwarzanie: Zadanie przechodzi przez stany pośrednie (np. oczekujące, w trakcie przetwarzania). W tym czasie środki są zablokowane, ale jeszcze nie pobrane ostatecznie.
  3. Zakończenie sukcesem: Zadanie otrzymuje status końcowy oznaczający powodzenie, a w odpowiedzi GET /v1/tasks/{id} pojawia się adres URL wygenerowanego pliku MP4. Zablokowana kwota zostaje rozliczona.
  4. Zakończenie błędem: Jeśli generacja nie powiedzie się po stronie silnika (np. błąd wewnętrzny modelu lub odrzucenie przez filtr bezpieczeństwa), zadanie przechodzi w stan błędu terminalnego. W Jantarisie nieudana generacja kosztuje 0 zł - zablokowana wcześniej kwota wraca do dyspozycji na saldzie.

Pułapka ponawiania POST vs bezpieczeństwo GET

W protokole HTTP metoda GET jest z definicji bezpieczna i idempotentna - wywołanie GET /v1/tasks/{id} dziesięć razy z rzędu nie zmienia stanu serwera i nie nalicza żadnych opłat. Z kolei metoda POST służy do tworzenia nowych zasobów i nie jest idempotentna sama z siebie.

Niebezpieczny scenariusz wygląda następująco:

  1. Twój skrypt wysyła POST /v1/generate.
  2. Serwer odbiera żądanie, tworzy zadanie nr 1 i blokuje np. 24,26 zł na saldzie.
  3. W ułamku sekundy, w którym odpowiedź z identyfikatorem zadania wraca przez internet, następuje krótkotrwałe zerwanie połączenia Wi-Fi, restart kontenera lub przekroczenie zbyt krótkiego limitu czasu odczytu (read timeout) w bibliotece HTTP.
  4. Domyślny mechanizm retry w bibliotece (np. urllib3 lub axios) uznaje, że żądanie się nie powiodło, i automatycznie wysyła drugi POST /v1/generate.
  5. Serwer traktuje to jako zupełnie nowe, niezależne zlecenie, tworzy zadanie nr 2 i blokuje kolejne 24,26 zł.

O ile publiczna dokumentacja konkretnego API nie potwierdza wprost obsługi specjalnych nagłówków idempotentności (np. Idempotency-Key), w kodzie klienckim nigdy nie należy zakładać, że serwer sam odfiltruje zduplikowane żądania POST. Całą ochronę przed podwójnym wysłaniem płatnego zlecenia trzeba zaimplementować po swojej stronie.

Wzorzec bezpiecznego przepływu pracy (krok po kroku)

Poniższe zalecenia to proponowana architektura kodu klienckiego, która chroni budżet przed błędami sieciowymi:

Krok 1: Wyłącz automatyczne retry dla metody POST

Konfigurując klienta HTTP (w Pythonie, Node.js czy w narzędziach no-code takich jak n8n i Make), ustaw liczbę automatycznych ponowień dla żądania POST /v1/generate dokładnie na zero. Jedynym wyjątkiem, w którym ponowienie jest bezpieczne bez interwencji, jest błąd połączenia na etapie samego zestawiania gniazda TCP/DNS (connect timeout), zanim jakiekolwiek bajty żądania opuściły Twój serwer. Jeśli jednak wystąpił błąd odczytu odpowiedzi (read timeout), skrypt musi się zatrzymać i zgłosić stan niepewny do weryfikacji.

Krok 2: Zapisz lokalny stan przed wysłaniem i zaraz po odebraniu ID

Zanim wyślesz żądanie, utwórz w lokalnej bazie danych (np. SQLite, PostgreSQL lub pliku JSON) rekord z unikalnym wewnętrznym identyfikatorem wiersza i statusem SENDING. Gdy tylko POST /v1/generate zwróci odpowiedź, natychmiast (przed jakimikolwiek innymi operacjami) zapisz otrzymany identyfikator zadania z API w tym rekordzie i zmień lokalny status na SUBMITTED. Dzięki temu, nawet jeśli Twój skrypt zostanie zatrzymany sekundę później, po ponownym uruchomieniu będzie wiedział, że nie wolno wysyłać kolejnego POST, lecz należy przejść od razu do odpytywania GET /v1/tasks/{id}.

Krok 3: Odpytuj GET z odstępem (backoff) i limitem czasu

Gdy masz już identyfikator zadania, możesz bezpiecznie ponawiać żądania GET /v1/tasks/{id}. Jeśli podczas pollingu wystąpi błąd sieciowy (np. timeout lub chwilowy błąd 502/503/504), po prostu odczekaj kilka sekund i wyślij GET ponownie. Ponieważ generowanie wideo trwa co najmniej kilkadziesiąt sekund, odpytywanie serwera co 500 milisekund nie przyspieszy renderowania, a jedynie wygeneruje zbędny ruch. Dobrą praktyką jest sprawdzanie statusu co 5-10 sekund.

Przykładowy kod w Pythonie (ilustracyjny wzorzec obsługi zadań)

Poniższy skrypt w języku Python przedstawia proponowaną strukturę rozdzielającą jednorazowe zlecenie POST od pętli odpytującej GET z lokalnym zapisem stanu do pliku. Uwaga: poniższy kod dla punktów końcowych POST i GET ma charakter wyłącznie ilustracyjny - nie był uruchamiany do wygenerowania wideo i nie zawiera rzeczywistego identyfikatora zadania ani wygenerowanego pliku. Dokładne nazwy pól statusu oraz strukturę obiektu odpowiedzi należy dostosować do aktualnej specyfikacji w dokumentacji API.

import json
import os
import time
import requests

API_KEY = os.environ.get("JANTARIS_API_KEY", "twoj_klucz_api")
BASE_URL = "https://jantaris.com/v1"
STATE_FILE = "video_task_state.json"

def load_state():
    if os.path.exists(STATE_FILE):
        with open(STATE_FILE, "r", encoding="utf-8") as f:
            return json.load(f)
    return None

def save_state(data):
    with open(STATE_FILE, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

def submit_video_task(prompt: str):
    """Wysyła POST dokładnie raz. Brak pętli retry dla POST."""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    payload = {
        "model": "kling-3.0",
        "prompt": prompt,
        "duration": 5,
        "resolution": "1080p"
    }
    
    # Zapisujemy informację o rozpoczęciu próby przed wysłaniem sieciowym
    save_state({"local_status": "SENDING", "task_id": None})
    
    try:
        # Krótki connect_timeout (5s), dłuższy read_timeout (30s)
        response = requests.post(
            f"{BASE_URL}/generate",
            headers=headers,
            json=payload,
            timeout=(5, 30)
        )
        response.raise_for_status()
        data = response.json()
        
        task_id = data.get("id")
        estimated_cost = data.get("estimated_cost")
        
        # Natychmiastowy zapis ID zadania na dysku
        save_state({
            "local_status": "SUBMITTED",
            "task_id": task_id,
            "estimated_cost": estimated_cost
        })
        return task_id
        
    except requests.exceptions.ConnectTimeout:
        # Połączenie nawet nie zostało nawiązane - bezpiecznie uznać za niewysłane
        save_state({"local_status": "NOT_SENT", "task_id": None})
        raise RuntimeError("Nie udało się połączyć z serwerem (ConnectTimeout). Zadanie nie zostało utworzone.")
    except requests.exceptions.ReadTimeout:
        # Żądanie wyszło, ale odpowiedź nie wróciła na czas - NIE PONAWIAMY POST!
        save_state({"local_status": "UNCERTAIN_TIMEOUT", "task_id": None})
        raise RuntimeError("Przekroczono czas oczekiwania na odpowiedź POST. Sprawdź historię zadań przed ponowieniem!")

def poll_task_status(task_id: str, interval_sec: int = 8, max_wait_sec: int = 600):
    """Bezpieczne odpytywanie GET z obsługą chwilowych błędów sieci."""
    headers = {"Authorization": f"Bearer {API_KEY}"}
    start_time = time.time()
    
    while (time.time() - start_time) < max_wait_sec:
        try:
            resp = requests.get(
                f"{BASE_URL}/tasks/{task_id}",
                headers=headers,
                timeout=(5, 15)
            )
            if resp.status_code in (502, 503, 504):
                # Błąd przejściowy bramki podczas GET - można bezpiecznie ponowić
                time.sleep(interval_sec)
                continue
                
            resp.raise_for_status()
            task_data = resp.json()
            status = task_data.get("status")
            
            # Wartości statusów dopasuj do dokumentacji API
            if status in ("succeeded", "completed"):
                save_state({"local_status": "DONE", "task_id": task_id, "result": task_data})
                return task_data
            elif status in ("failed", "canceled", "error"):
                save_state({"local_status": "FAILED", "task_id": task_id, "error": task_data})
                raise RuntimeError(f"Zadanie zakończone błędem: {task_data}")
                
        except requests.exceptions.RequestException as e:
            # Błąd sieci podczas GET nie tworzy duplikatów - czekamy i próbujemy dalej
            print(f"Chwilowy błąd odczytu statusu GET: {e}. Ponawiam za {interval_sec} s...")
            
        time.sleep(interval_sec)
        
    raise TimeoutError(f"Zadanie {task_id} nie zakończyło się w ciągu {max_wait_sec} sekund.")

Jak reagować na poszczególne kody HTTP

Projektując logikę obsługi błędów w integracji API, warto rozróżnić kody błędów według tego, czy dotyczą one tworzenia zadania, czy sprawdzania jego statusu.

Zdarzenie / Kod HTTPPodczas POST /v1/generatePodczas GET /v1/tasks/{id}Zalecane działanie w skrypcie
400 / 401 / 402 / 422Żądanie odrzucone przed utworzeniem zadaniaBłędny klucz lub niepoprawne IDNie ponawiaj automatycznie. Popraw parametry, klucz API lub doładuj saldo.
429 Too Many RequestsPrzekroczony limit zapytańZbyt częsty pollingZwiększ odstęp między zapytaniami (np. z 2 s na 10 s).
502 / 503 / 504 lub ReadTimeoutStan niepewny (zadanie mogło powstać)Chwilowa niedostępność odczytuDla POST: przerwij i zweryfikuj saldo/historię. Dla GET: odczekaj i ponów.
Status zadania: błąd terminalnyNie dotyczyGeneracja nieudana po stronie modeluZwolnienie blokady środków (koszt 0 zł). Ewentualne nowe zlecenie wymaga świadomej decyzji.

Aspekty rozliczeniowe i organizacyjne w firmie

Dobra kontrola nad asynchronicznymi zadaniami ma bezpośrednie przełożenie na księgowość i budżetowanie projektów wideo (np. przy seryjnym tworzeniu materiałów takich jak reklama produktu z AI czy klip AI do rolki 9:16). Korzystając z oficjalnych, zagranicznych platform producentów modeli, rozliczenia prowadzone są w USD przy płatności kartą, a interfejsy są anglojęzyczne.

W polskim wariancie mojego serwisu całe saldo prowadzone jest w złotówkach (doładowanie od 40 zł przez BLIK lub kartę, bez abonamentu i bez wygasania środków), a po zaznaczeniu odpowiedniej opcji przy doładowaniu wystawiana jest polska faktura VAT z NIP-em (więcej o księgowaniu takich wydatków przeczytasz w artykule Faktura VAT za API AI). Z kolei jeśli zamiast pisać własne skrypty w Pythonie korzystasz z asystentów kodowania obsługujących protokół MCP, sprawdzanie statusu zadania może przejąć sam agent - szczegółowo opisałem to w poradniku MCP do obrazów i wideo w Claude Code, Codex i Cursor. Pamiętaj też, że niezależnie od wybranego narzędzia i warunków cenowych, przy komercyjnym wykorzystaniu generowanych multimediów zawsze musisz posiadać odpowiednie prawa do materiałów wejściowych (np. zdjęć lub nagrań przesyłanych do animacji).

Najczęściej zadawane pytania (FAQ)

Czy wielokrotne sprawdzanie statusu przez GET /v1/tasks/{id} jest płatne?

Nie. Opłata w API naliczana jest wyłącznie za samo wygenerowanie materiału multimedialnego zlecone przez POST /v1/generate. Odpytywanie punktu końcowego GET /v1/tasks/{id} służy jedynie do pobrania informacji o postępie i nie pomniejsza salda konta.

Co dzieje się z pieniędzmi na saldzie, jeśli zadanie wideo zakończy się błędem?

W momencie przyjęcia zlecenia POST /v1/generate szacowana kwota (estimated_cost) jest jedynie blokowana na koncie. Jeżeli zadanie zakończy się niepowodzeniem po stronie modelu, generacja kosztuje 0 zł, a blokada środków zostaje zwolniona.

Jak często powinienem odpytywać API o status generowanego wideo?

W przypadku modeli wideo optymalny interwał to od 5 do 10 sekund. Odpytywanie serwera co sekundę lub częściej nie przyspieszy procesu renderowania na kartach graficznych, a może doprowadzić do tymczasowego ograniczenia zapytań (błąd HTTP 429).

Dlaczego nie należy włączać automatycznego retry dla POST /v1/generate przy błędach timeout?

Przekroczenie czasu oczekiwania na odczyt odpowiedzi (read timeout) często oznacza, że serwer przyjął już zlecenie i rozpoczął kosztowne renderowanie, ale odpowiedź z identyfikatorem nie zdążyła dotrzeć do klienta. Automatyczne wysłanie drugiego żądania POST utworzy drugie, osobno płatne zadanie wideo.

Skąd mam wiedzieć przed wysłaniem zadania, ile dokładnie będzie kosztować wygenerowanie klipu?

Aktualne ceny jednostkowe za sekundę lub za cały plik wideo oraz warianty rozdzielczości można pobrać programistycznie z publicznego punktu końcowego GET https://jantaris.com/v1/models?currency=PLN. Dodatkowo odpowiedź na POST /v1/generate zwraca pole estimated_cost z wyliczoną kwotą dla danego zlecenia.

Nie przepłacaj za te subskrypcje

Prowadzę sklep z rocznymi dostępami do narzędzi AI - te same konta, o których piszę wyżej, tylko taniej niż w cenniku producenta.

Zobacz, co jest dostępne

Czytasz Promptowego częściej? Dodaj go do preferowanych źródeł w Google, a nowe teksty będą wyżej w Twoich wynikach.

Przewodnik na ten temat

21 konkretnych metod zarabiania na AI

Pełny przewodnik: freelancing, produkty cyfrowe i własny biznes - z konkretnymi progami wejścia zamiast ogólników.

Źródła

Najczęstsze pytania

Dlaczego generowanie wideo przez API działa asynchronicznie, a nie synchronicznie?

Generowanie wideo trwa kilkadziesiąt sekund lub kilka minut, co przekracza domyślne limity czasu serwerów HTTP ustawione zazwyczaj na 30, 60 lub 120 sekund. Dlatego API najpierw przyjmuje zlecenie przez POST i zwraca identyfikator zadania, a klient cyklicznie sprawdza status przez GET /v1/tasks/{id}.

Ile kosztuje pojedyncze wideo wygenerowane modelem Veo 3.1 Quality w rozdzielczości 4K?

Jeden plik wideo w wariancie 4K kosztuje 21,88069 zł brutto. Trzykrotne omyłkowe wysłanie tego samego żądania POST zablokuje łącznie 65,64 zł na saldzie.

Co się dzieje z zablokowanymi środkami, gdy generacja wideo zakończy się błędem?

Nieudana generacja kosztuje 0 zł - zablokowana wcześniej kwota wraca do dyspozycji na saldzie. Środki są pobierane ostatecznie dopiero po pomyślnym zakończeniu zadania.

Jak zabezpieczyć skrypt przed podwójnym wysłaniem płatnego zlecenia wideo?

Należy ustawić liczbę automatycznych ponowień dla POST /v1/generate dokładnie na zero oraz zapisywać lokalny rekord z identyfikatorem zadania natychmiast po odebraniu odpowiedzi. Dzięki temu po restarcie skryptu można sprawdzić, czy zlecenie zostało już wysłane, zamiast tworzyć nowe zadanie.

Link do Kimi jest partnerski: jeśli kupisz przez niego, serwis dostaje prowizję, a Ty płacisz tyle samo. Nie wpływa to na treść, także tam, gdzie piszę krytycznie.

Piotr Olszewski

Autor

Twórca i autor Promptowego, polskiego serwisu o sztucznej inteligencji. Codziennie śledzi premiery modeli, narzędzia i regulacje AI, i tłumaczy je prostym, konkretnym językiem.

O mnie →Wszystkie teksty →

Czytaj dalej

Narzędzia do tego tematu

darmowe, bez kontaWszystkie 29 →
z sieci - nowe teksty w moich serwisach

Wszystkie moje projekty →

Najczęściej czytane

7 dni
  1. 1Plakat festiwalu z polskim napisem: prompt i test 6 generatorów obrazu (Prompt dnia 14.11)
  2. 2Claude Fable 5.2 czy Opus 5.5: kiedy dopłata 2 razy ma sens, a kiedy to wyrzucone pieniądze
  3. 330 promptów do ChatGPT Images i 10 do przerabiania zdjęć
🛒 Sklep Kinetyka CapCut Pro 460 zł/rok Lovable Pro 450 zł/rok Replit Core 119 zł/rok Zobacz wszystko →