Przez API v1 Elbuz wydaje i przyjmuje produkty, kategorie, kontrahentów i dokumenty zapytaniami POST z tokenem. Każda operacja jest tu opisana z działającym przykładem w PHP i prawdziwą odpowiedzią serwera.
Kiedy to się przyda:
- Trzeba utrzymać integrację napisaną na v1 — pełna lista operacji i słowników.
- Zapytanie odpowiada kodem 200, a danych nie ma — błąd rozpoznaje się po strukturze odpowiedzi.
- Przychodzi dokładnie 100 rekordów — strony do 500 rekordów i przechodzenie do końca.
- Trzeba pobierać tylko zmiany — gotowy przepis na synchronizację przyrostową.
Od czego zacząć: minimalny skrypt — logowanie, zapytanie, wydruk wyniku.
Co potrafi API v1
- Logowanie kluczem — jedno
api/login, dalej zapytania z tokenem. - Czytać prawie wszystkie słowniki — produkty, wiersze cenników, kategorie, kontrahentów, dokumenty, artykuły, statusy.
- Przeglądać rekordy stronami do 500 rekordów, filtrować jak w tabelach i pobierać zdjęcia oraz cechy razem z produktem.
- Dodawać, zmieniać i usuwać — produkty pakietem do 10 000 na zapytanie.
- Zwracać nazwy pól — rejestr pól z etykietami i typami.
- Gotowe przepisy — synchronizacja zmian, import pakietowy, stany dla strony.
Nową integrację pisz od razu na API v2: v1 jest oznaczone jako przestarzałe (jak przejść).
Jak wysłać pierwsze zapytanie
Minimalny działający skrypt: logowanie, zapytanie o dane, wydruk wyniku. Wstaw swój adres, nazwę użytkownika i klucz.
<?php
$host = 'https://twoje-konto.elbuz.com'; // adres Twojego konta
$user = 'site'; // „Użytkownik” z karty klucza
$key = 'TWÓJ_KLUCZ'; // „Klucz dostępu”
function elbuz_call($host, $route, array $post) {
$ch = curl_init($host . '/admin/index.php?route=' . $route);
curl_setopt_array($ch, array(
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($post),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 120,
));
$body = curl_exec($ch);
return json_decode($body, true);
}
// 1. logowanie — otrzymujemy token
$login = elbuz_call($host, 'api/login', array('username' => $user, 'key' => $key));
if (empty($login['api_token'])) {
exit('Nie udało się zalogować: ' . json_encode($login, JSON_UNESCAPED_UNICODE));
}
$token = $login['api_token'];
// 2. zapytanie o dane
$res = elbuz_call($host, 'api/scope/get', array(
'api_token' => $token,
'scope' => 'category',
'max_rows' => 2,
'limit_field' => 'name',
));
print_r($res);
Odpowiedź na logowanie:
{
"success": "Sesja API została rozpoczęta!",
"api_token": "b439dd5c3b386d36464bef450d"
}
Odpowiedź na zapytanie o kategorie — dokładnie to, co zwrócił serwer:
{
"item_list": {
"83": {
"category_id": "83",
"parent_id": "11",
"name": "Płyty grzewcze"
},
"84": {
"category_id": "84",
"parent_id": "11",
"name": "Okapy do zabudowy"
}
},
"meta": {
"item_scope": "category",
"total_row": 234,
"page_total": 117,
"page_next": 2,
"page_current": 1,
"request_time": "00:00:00"
}
}
Zwróć uwagę: w zapytaniu było limit_field=name, a w odpowiedzi są jeszcze category_id i parent_id. Tak ma być — pola obowiązkowe słownika są dodawane zawsze.
Jak działa protokół: token, częstotliwość, język
| Co | Jak |
|---|---|
| Adres bazowy | adres konta + /admin/index.php?route= + trasa |
| Metoda | tylko POST |
| Treść zapytania | zwykły formularz, application/x-www-form-urlencoded |
| Odpowiedź | z nagłówkiem Content-Type: application/json |
| Kod HTTP | zawsze 200 — nawet przy błędzie |
| Token | parametr api_token w treści POST lub w adresie |
Nie kieruj się kodem HTTP: błąd też przychodzi z kodem 200. Analizuj strukturę: błąd to tablica JSON z ciągami znaków, udana odpowiedź — obiekt z item_list lub meta.
Czas życia tokena
Token to identyfikator sesji. Sesje, do których nie odwoływano się dłużej niż godzinę, są usuwane; każde zapytanie z tokenem przedłuża sesję. Dlatego stale działająca integracja loguje się raz, a nowe api/login wykonuje tylko w odpowiedzi na błąd dostępu.
function elbuz_get($host, $user, $key, &$token, array $post) {
$post['api_token'] = $token;
$res = elbuz_call($host, 'api/scope/get', $post);
// błąd przychodzi tablicą ciągów — możliwe, że sesja wygasła
if (isset($res[0]) && is_string($res[0])) {
$login = elbuz_call($host, 'api/login', array('username' => $user, 'key' => $key));
if (empty($login['api_token'])) return $res; // to nie kwestia sesji
$token = $login['api_token'];
$post['api_token'] = $token;
$res = elbuz_call($host, 'api/scope/get', $post);
}
return $res;
}
Limit częstotliwości
Klucz ma limit odwołań — domyślnie 30 na minutę. Działa on jako minimalny odstęp: 60 podzielone przez tę liczbę, czyli domyślnie nie częściej niż raz na dwie sekundy. Nie da się uzbierać przerwy i wysłać serii zapytań jedno po drugim — odrzucone zostanie każde, które przyszło przed upływem odstępu.
{"Error": "Rate limit exceeded! Time passed:0.0582 Time minimal request:0.1"}
W odpowiedzi widać obie liczby: ile minęło od poprzedniego zapytania i ile jest wymagane. Format jest tu inny niż w pozostałych błędach — klucz Error wielką literą i obiekt zamiast tablicy. Obsługuj oba warianty:
if (isset($res['Error'])) { // limit częstotliwości
sleep(2);
// powtórz to samo zapytanie
}
if (isset($res[0]) && is_string($res[0])) { // zwykły błąd API
throw new RuntimeException($res[0]);
}
Limitu nie zmienia się w interfejsie — w tej sprawie napisz do wsparcia technicznego.
- Початок або кінець
- Дія або результат
- Розвилка: далі шлях залежить від відповіді
Język odpowiedzi
Teksty przychodzą w języku pracownika, w imieniu którego działa klucz — czyli właściciela konta. Natomiast błąd dostępu bez tokena przychodzi w domyślnym języku bazy, bo pracownik nie jest jeszcze ustalony. Czyli dwa komunikaty tego samego API mogą być w różnych językach. To kolejny argument, by analizować odpowiedź po strukturze, a nie po tekście.
Jakie są operacje i słowniki
| Trasa | Przeznaczenie | Parametry obowiązkowe |
|---|---|---|
api/login | otrzymać token | username, key |
api/scope/describe | opis pól słownika | api_token, scope |
api/scope/get | pobrać rekordy | api_token, scope |
api/scope/add | dodać rekord lub pakiet | api_token, scope + pola rekordu |
api/scope/update | zaktualizować | api_token, scope, identyfikator |
api/scope/delete | usunąć | api_token, scope, identyfikator |
api/scope/search | wyszukiwanie produktów indeksem wyszukiwania | api_token, scope=product |
Słownik podaje się parametrem scope albo dopisuje do trasy — oba warianty są równoważne:
api/scope/get + scope=currency
api/scope/get/currency
Słowniki według operacji
Zestawy są różne. To pierwsza rzecz, którą warto sprawdzić przed zaprojektowaniem integracji: czytać można prawie wszystko, zmieniać — zdecydowanie nie wszystko.
| Operacja | Kody słowników |
|---|---|
get | category, product, product_price, attribute, attribute_block, language, article, manufacturer, stock_status, warehouse, store, company, contractor, contractor_group, currency, document, document_type, document_status, document_payment_status, document_delivery_status, print_template |
add | category, product, product_price, manufacturer, contractor, document, document_extended, user, company, attribute, attribute_block, article, contractor_price, mail_send |
update | category, product, currency, contractor, document |
delete | category, product, contractor, attribute_block, attribute, manufacturer, article, document |
describe | product, product_price, manufacturer, contractor, document, user, company |
search | product |
product_price jest w dodawaniu, ale nie ma go w aktualizacji: wiersze cennika przez API się tworzy, a zmienia tylko importem cennika. Uwzględnij to, planując integrację.
Jak poznać nazwy pól: describe
Nazwy pól w zapytaniach to nie te, które widać w interfejsie. describe zwraca rejestr pól: nazwę wewnętrzną, czytelną etykietę i typ.
$res = elbuz_call($host, 'api/scope/describe', array(
'api_token' => $token,
'scope' => 'contractor',
'limit_field' => 'datafield,datafield_type,grid_field_name',
));
{
"item_list": {
"347": {"row_id": "347", "datafield": "name", "datafield_type": "string", "grid_field_name": "Nazwa"},
"349": {"row_id": "349", "datafield": "phones", "datafield_type": "string", "grid_field_name": "Telefon"},
"560": {"row_id": "560", "datafield": "status_name", "datafield_type": "string", "grid_field_name": "Etap klienta"},
"562": {"row_id": "562", "datafield": "manager_name", "datafield_type": "string", "grid_field_name": "Opiekun (menedżer)"}
},
"meta": {"item_scope": "contractor", "total_row": 118, "page_total": 1, "page_next": 0, "page_current": 1, "request_time": "00:00:00"}
}
To ten sam rejestr, który widać w oknie „Skonfiguruj tabelę” z przełącznikiem „Nazwy techn.”. Bez limit_field każde pole przychodzi z kilkudziesięcioma właściwościami technicznymi — bierz trzy potrzebne kolumny.
Jak czytać rekordy: get
Parametry
| Parametr | Domyślnie | Co robi |
|---|---|---|
scope | — | kod słownika, obowiązkowy |
page | 1 | numer strony |
max_rows | 100 | rekordów na stronie. Limit 500; więcej jest po prostu obcinane |
language_id | język konta | język pól tekstowych |
limit_field | wszystkie pola | lista potrzebnych pól rozdzielona przecinkami |
extend | — | dane zagnieżdżone: zdjęcia, cechy, pozycje dokumentu |
filterscount i kolejne | — | warunki filtrowania |
Pola obowiązkowe
Nawet jeśli o nie nie prosisz, te pola przychodzą zawsze — bez nich nie da się dopasować odpowiedzi do Twoich danych:
| Słownik | Dodawane zawsze |
|---|---|
product | product_id, name, price |
product_price | supply_product_id, contractor_id, price_id, product_id, sku_manufacturer, manufacturer, name, price, stock_status_id, field_ssd_stock_status_name |
category | category_id, parent_id, name |
document | document_id, contractor_id, type_id, document_type_name, document_number |
attribute | attribute_id, attribute_name |
language | language_id, code, name |
print_template | nic nie jest dodawane |
| pozostałe | własny identyfikator i name |
Strony
Rekordy przychodzą obiektem, a nie tablicą: kluczem jest identyfikator rekordu. W bloku meta jest wszystko do przechodzenia po stronach, a znakiem końca jest page_next równe zeru.
$page = 1;
$all = array();
do {
$res = elbuz_call($host, 'api/scope/get', array(
'api_token' => $token,
'scope' => 'product',
'max_rows' => 500, // limit w chmurze
'limit_field' => 'product_id,name,price,quantity',
'page' => $page,
));
if (!isset($res['item_list'])) break; // błąd lub pusty wynik
$all += $res['item_list']; // klucze = ID, duplikatów nie będzie
$page = (int)$res['meta']['page_next'];
sleep(2); // domyślny limit częstotliwości
} while ($page > 0);
echo 'pobrano: ' . count($all);
Na słowniku walut z trzynastoma rekordami, po pięć na stronę, ta pętla wykonuje dokładnie trzy zapytania: trzecia strona zwraca page_next: 0 i przechodzenie się kończy.
Pusty wynik to nie pusty item_list, tylko błąd „Nie znaleziono elementu”. Jeśli filtr niczego nie przepuścił, sprawdzenie isset($res['item_list']) przerwie pętlę — dlatego stoi ono przed analizą odpowiedzi.
Jak filtrować rekordy i pobierać zdjęcia oraz cechy
Filtry
Dla product i document działa to samo filtrowanie co w tabelach interfejsu: filterscount — liczba warunków, dalej dla każdego czwórka parametrów z numerem, liczonym od zera.
| Parametr | Wartość |
|---|---|
filterdatafield0 | pole, jak w describe |
filtervalue0 | wartość |
filtercondition0 | EQUAL, NOT_EQUAL, CONTAINS, STARTS_WITH, GREATER_THAN, GREATER_THAN_OR_EQUAL, LESS_THAN, LESS_THAN_OR_EQUAL |
filteroperator0 | 0 — połączyć z następnym warunkiem przez „i”, 1 — przez „lub” |
Produkty zmienione po podanej dacie:
$res = elbuz_call($host, 'api/scope/get', array(
'api_token' => $token,
'scope' => 'product',
'max_rows' => 2,
'limit_field' => 'product_id,name,quantity,date_modified',
'filterscount' => 1,
'filterdatafield0' => 'date_modified',
'filtervalue0' => '2026-01-01',
'filtercondition0' => 'GREATER_THAN_OR_EQUAL',
'filteroperator0' => 0,
));
{
"item_list": {
"6068": {
"product_id": "6068",
"price": "1200.00000000",
"quantity": "0",
"date_modified": "2026-09-12 14:54:23",
"name": "Ardesto LESH-Y305"
}
},
"meta": {
"item_scope": "product",
"total_row": 126999,
"page_total": 63500,
"page_next": 2,
"page_current": 1,
"request_time": "00:00:00"
}
}
Można też filtrować po cechach: nazwa pola to attribute_ plus numer cechy, który podaje describe.
Dane zagnieżdżone
Zdjęcia, cechy i pozycje dokumentu nie są częścią samego rekordu — dołącza się je parametrem extend, wartości rozdzielone przecinkami.
| Słownik | Wartość extend | Pole w odpowiedzi |
|---|---|---|
product | attribute, image, file, video, category | extend_attribute, extend_image, extend_file, extend_video, extend_category |
product_price | attribute, image | te same |
document | contractor, product | extend_contractor, extend_product |
$res = elbuz_call($host, 'api/scope/get', array(
'api_token' => $token,
'scope' => 'product',
'max_rows' => 1,
'limit_field' => 'product_id,name',
'extend' => 'image,category',
));
{
"item_list": {
"6068": {
"product_id": "6068",
"price": "1200.00000000",
"name": "Ardesto LESH-Y305",
"extend_image": [
{
"product_image_id": "201587",
"image": "100/68/product_image_6068_201587.jpg",
"sort_order": "1",
"image_original": "https://…/product_image_6068_201587.jpg",
"image_cloud_url": ""
}
],
"extend_category": [ {"category_id": "1201"} ]
}
}
}
Zestawem pól bloku zagnieżdżonego też da się sterować: extend_limit_field_attribute, extend_limit_field_image, extend_limit_field_product i podobne. Domyślnie dla cech są to attribute_id, attribute_name, attribute_value, dla pozycji dokumentu — product_id, sku, mpn, name, quantity, price, price_sum, ean, isbn.
Z parametrem extend zmienia się postać odpowiedzi: item_list przestaje być obiektem z kluczami-identyfikatorami i przychodzi jako zwykła lista. Kod napisany bez extend zepsuje się dokładnie wtedy, gdy ktoś go doda. Obsługuj od razu obie postacie:
$rows = $res['item_list'];
$rows = isset($rows[0]) ? $rows : array_values($rows); // tak samo dla obu postaci
foreach ($rows as $row) { /* … */ }
Jak dodać, zmienić i usunąć: add, update, delete
Odpowiedź we wszystkich trzech jest taka sama i krótka:
{"meta": {"item_scope": "product", "result": 1024, "request_time": "00:00:00"}}
W result jest to, co zwróciła operacja: przy dodawaniu — identyfikator nowego rekordu, w pozostałych — znak powodzenia. Osobnego pola z tekstem błędu walidacji nie ma: jeśli rekord nie powstał, result będzie pusty.
Operacje pakietowe na produktach odpowiadają inaczej: w result jest obiekt. Po dodaniu zawiera status, total_item_add — ile produktów utworzono, i item_list_add — listę właśnie utworzonych, z product_id i uuid każdego. Po aktualizacji — total_item_update. Jeśli pakiet odrzucono w całości, status jest równy 0, a w status_text jest przyczyna: np. „Nieznane pole” z nazwą pola albo „Maksymalna liczba produktów” z limitem.
Porównuj total_item_add z liczbą wysłanych wierszy: część wierszy pakiet pomija bez błędu, o czym mówi rozdział o przerwaniu i powtórzeniu.
Operacje pakietowe
Zamiast pól jednego rekordu przekazuje się item_list — listę rekordów:
$res = elbuz_call($host, 'api/scope/add', array(
'api_token' => $token,
'scope' => 'product',
'item_list' => array(
array('name' => 'Produkt 1', 'price' => 100, 'sku' => 'A-001'),
array('name' => 'Produkt 2', 'price' => 200, 'sku' => 'A-002'),
),
));
| Słownik | Operacja | Rekordów naraz |
|---|---|---|
product | dodawanie i aktualizacja | do 10 000 |
product_price | dodawanie | do 100 |
Pakiet to nie tylko wygoda. Przy limicie jednego zapytania na dwie sekundy dziesięć tysięcy produktów pojedynczo to prawie sześć godzin, pakietem — jedno zapytanie.
Oznaczenie źródła
Parametr source_code w dodawaniu oznacza, skąd przyszły dane; oznaczenie trafia do pola produktu „Źródło: kod” i potem widać, że produkt utworzyła właśnie ta integracja, a nie człowiek. Bez parametru ustawiane jest jumper.
Aktualizacja pakietowa api/scope/update nie bierze oznaczenia z zapytania: każdemu zaktualizowanemu produktowi zapisuje w „Źródło: kod” wartość api. Czyli Twoje oznaczenie żyje, dopóki produktu nie zaktualizowano pakietem — uwzględnij to, jeśli zamierzasz szukać po nim produktów integracji (wycofanie błędnego pakietu).
Usuwanie
Identyfikator przekazuje się w polu o nazwie słownika: category_id, product_id, manufacturer_id, attribute_id, attribute_block_id, article_id, document_id.
Przekazuj tylko pole odpowiadające słownikowi. Jeśli potrzebnego identyfikatora nie ma, zapytanie nie zakończy się błędem — przetwarzanie pójdzie dalej po liście słowników i może dojść do usunięcia dokumentu, jeśli w treści zapytania znajdzie się document_id. Odpowiedź przy tym poda słownik, o który prosiłeś. Nie buduj uniwersalnej treści zapytania z identyfikatorami różnych słowników.
Zatwierdzone dokumenty nie są usuwane — taka próba zwraca pusty wynik.
Jakie błędy zwraca API
Błędy api/scope/* przychodzą tablicą z jednym ciągiem znaków:
["Uwaga: brak uprawnień do zmiany danych!"]
| Komunikat | Przyczyna | Co zrobić |
|---|---|---|
| brak uprawnień dostępu do API | nie przekazano tokena, sesja wygasła lub klucz jest wyłączony | powtórz api/login; jeśli nie pomogło — sprawdź „Aktywność” |
| brak uprawnień do zmiany danych | klucz ma zaznaczone „Tylko do odczytu” | odznacz pole w karcie klucza |
| Nie podano kodu słownika | brak parametru scope | dodaj scope lub dopisz go do trasy |
| Nieznany kod słownika | słownik nie jest obsługiwany przez tę operację | sprawdź w tabeli słowników |
| Nie znaleziono elementu | wynik jest pusty | sprawdź filtr; to nie awaria |
{"error":{"key":"UWAGA: nieprawidłowy klucz API!"}} | logowanie nie przeszło autoryzacji: para „Użytkownik” + „Klucz dostępu” nie zgadza się z kartą, w karcie odznaczono „Aktywność” albo minęła „Data wygaśnięcia dostępu”. Ta sama odpowiedź dla wszystkich trzech przyczyn | porównaj username i key z kartą klucza, sprawdź „Aktywność” i datę; pusty username daje „UWAGA: nieprawidłowa nazwa użytkownika!” |
{"error":{"ip":"UWAGA: Twój adres IP … nie jest na liście dostępu do API!"}} | logowanie: klucz jest poprawny, ale adresu nie ma na liście „Adresy IP z dostępem” | adres jest podany w treści błędu — wpisz go do klucza |
{"Error":"Rate limit exceeded…"} | zapytania częściej niż dozwolony odstęp | przerwa i powtórzenie |
Udane zapytania są zapisywane w dzienniku pracy jako operacja typu „api” razem z treścią odpowiedzi — to najprostszy sposób, by zobaczyć, co dokładnie robiła integracja. Odpowiedzi z błędem (brak uprawnień, nieznany słownik, „Nie znaleziono elementu” itp.) i add, który niczego nie dodał, do dziennika nie trafiają — takich awarii szukaj w odpowiedziach, które otrzymała Twoja integracja.
Gotowe przepisy
Przyrostowa synchronizacja katalogu
Zamiast co noc pobierać cały katalog, pobieraj to, co zmieniło się od ostatniego razu.
$since = file_exists('last_sync.txt') ? trim(file_get_contents('last_sync.txt')) : '2000-01-01';
$started = date('Y-m-d H:i:s');
$page = 1;
do {
$res = elbuz_call($host, 'api/scope/get', array(
'api_token' => $token,
'scope' => 'product',
'max_rows' => 500,
'limit_field' => 'product_id,name,price,quantity,sku',
'page' => $page,
'filterscount' => 1,
'filterdatafield0' => 'date_modified',
'filtervalue0' => $since,
'filtercondition0' => 'GREATER_THAN_OR_EQUAL',
'filteroperator0' => 0,
));
if (!isset($res['item_list'])) break; // „Nie znaleziono elementu” = brak zmian
foreach ($res['item_list'] as $id => $row) {
// Twoja logika: zaktualizuj produkt w swoim systemie
}
$page = (int)$res['meta']['page_next'];
sleep(2);
} while ($page > 0);
file_put_contents('last_sync.txt', $started); // czas STARTU, a nie zakończenia
Zapisuj czas startu przebiegu: to, co zmieniło się w trakcie przechodzenia, trafi wtedy do następnego przebiegu, zamiast zgubić się między nimi.
Usuniętych produktów ta pętla nigdy nie zobaczy — jak je wykrywać, opisuje rozdział o usuniętych i zniknięciach.
Pakietowy import produktów
$products = array( /* Twoja tablica produktów */ );
foreach (array_chunk($products, 1000) as $chunk) {
do {
$res = elbuz_call($host, 'api/scope/add', array(
'api_token' => $token,
'scope' => 'product',
'source_code' => 'my_erp', // oznaczenie źródła w polu „Źródło: kod”
'item_list' => $chunk, // każdy produkt z Twoim uuid, zob. niżej
));
sleep(2);
} while (isset($res['Error'])); // limit częstotliwości — powtórz tę samą paczkę
}
Powtórzenie idzie tu pętlą wokół tej samej paczki. Proste continue przeszłoby do następnej paczki i odrzucony tysiąc produktów w ogóle nie trafiłby do Elbuz.
Tysiąc rekordów w paczce to kompromis: limit wynosi 10 000, ale im większa paczka, tym dłuższa odpowiedź i tym boleśniejsze powtórzenie, jeśli zapytanie się przerwie.
Przekazać stronie stany i ceny
Najczęstsze zadanie — i najtańsze: potrzebne są trzy pola, więc odpowiedź jest mała, a stron niewiele.
$res = elbuz_call($host, 'api/scope/get', array(
'api_token' => $token,
'scope' => 'product',
'max_rows' => 500,
'limit_field' => 'sku,price,quantity', // product_id i name zostaną dodane same
));
Co zrobić, gdy zapytanie nie działa
| Co widzisz | Dlaczego tak jest | Co zrobić |
|---|---|---|
| Działało, a po godzinie przestało | sesja tokena wygasła z braku odwołań | zaloguj się ponownie przy błędzie dostępu |
| „Rate limit exceeded” przy co drugim zapytaniu | zapytania idą częściej niż odstęp | przerwa między zapytaniami lub operacje pakietowe |
| Przychodzi dokładnie 100 rekordów | domyślny rozmiar strony | max_rows do 500 i przechodzenie po page_next |
| Przechodzenie po stronach się zapętliło | nie jest sprawdzane page_next | zero oznacza koniec |
| W odpowiedzi są zbędne pola | pola obowiązkowe słownika są dodawane zawsze | tak ma być |
Po dodaniu extend zepsuła się analiza odpowiedzi | item_list stał się listą zamiast obiektu | obsługuj obie postacie |
| Pusty wynik przychodzi jako błąd | tak odpowiada get, gdy nic nie znaleziono | sprawdzaj obecność item_list |
| Aktualizacja wierszy cennika nie działa | product_price nie ma na liście aktualizacji | aktualizuj cennik importem pliku |
Najczęstsze pytania
Czy trzeba logować się przed każdym zapytaniem?
Nie. Sesja żyje, dopóki się z niej korzysta, i jest usuwana po godzinie bez odwołań. Ponowne logowanie wykonuj w odpowiedzi na błąd dostępu (czas życia tokena).
Ile zapytań na minutę jest dozwolonych?
Domyślnie trzydzieści, a liczą się one jako minimalny odstęp: nie częściej niż raz na dwie sekundy. Serii zapytań jedno po drugim wysłać się nie da, nawet po długiej przerwie (limit częstotliwości).
Jak synchronizować katalog bez pobierania go w całości?
Filtrem po date_modified z datą ostatniej synchronizacji. Zapisuj czas startu przebiegu, a nie zakończenia (przepis).
Jak zaimportować wiele produktów naraz?
Parametrem item_list w operacji dodawania: produktów katalogu — do dziesięciu tysięcy na zapytanie, wierszy cennika — do stu (operacje pakietowe).
Czy można kierować się kodem odpowiedzi HTTP?
Nie, zawsze jest to 200 — i przy sukcesie, i przy błędzie. Błąd przychodzi tablicą ciągów znaków, sukces zawiera item_list lub meta.
Gdzie to jest i kto ma dostęp
Okna w nie ma: zapytania idą na adres konta, a klucz wydaje się w oknie „API i tokeny dostępu”.
- Adres
- adres konta +
/admin/index.php?route=+ trasa - Klucz
- karta klucza v1: pola „Użytkownik” i „Klucz dostępu” (pola klucza)
- Przygotuj
- klucz utworzony przed 14.10.2026: nowy klucz działa tylko z API v2
Powiązane tematy
- Jeśli potrzebujesz ogólnego obrazu i przejścia na API v2 — stare API v1: klucz i przejście.
- Jeśli pakiet zapisuje produkty i ceny na działającym koncie — co API v1 robi z danymi.
- Jeśli trzeba zobaczyć, co dokładnie robiła integracja — dziennik pracy.
- Jeśli nazw pól wygodniej szukać w programie — ustawienia tabeli.
