<!doctype html>
<html data-n-head-ssr lang="pl" data-n-head="lang">
  <head data-n-head="">
    <title data-n-head="true">Polityka prywatności - TGI smart</title><meta data-n-head="true" charset="utf-8"/><meta data-n-head="true" name="viewport" content="width=device-width, initial-scale=1"/><meta data-n-head="true" property="og:image" content="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/og-image.jpg"/><meta data-n-head="true" name="msapplication-TileColor" content="#ffffff"/><meta data-n-head="true" name="msapplication-TileImage" content="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/mstile-144x144.png"/><meta data-n-head="true" property="og:title" content="Polityka prywatności - TGI smart"/><meta data-n-head="true" data-hid="description" property="og:description" name="description" content="Polityka prywatności platformy TGI smart"/><meta data-n-head="true" data-hid="keywords" name="keywords" content="null"/><link data-n-head="true" rel="icon" type="image/x-icon" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/favicon.ico"/><link data-n-head="true" rel="icon" type="image/png" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/favicon-16x16.png" sizes="16x16"/><link data-n-head="true" rel="icon" type="image/png" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/favicon-32x32.png" sizes="32x32"/><link data-n-head="true" rel="icon" type="image/png" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/favicon-96x96.png" sizes="96x96"/><link data-n-head="true" rel="icon" type="image/png" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/favicon-128x128.png" sizes="128x128"/><link data-n-head="true" rel="icon" type="image/png" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/favicon-196x196.png" sizes="196x196"/><link data-n-head="true" rel="apple-touch-icon" sizes="57x57" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-57x57.png"/><link data-n-head="true" rel="apple-touch-icon" sizes="60x60" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-60x60.png"/><link data-n-head="true" rel="apple-touch-icon" sizes="72x72" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-72x72.png"/><link data-n-head="true" rel="apple-touch-icon" sizes="76x76" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-76x76.png"/><link data-n-head="true" rel="apple-touch-icon" sizes="114x114" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-114x114.png"/><link data-n-head="true" rel="apple-touch-icon" sizes="120x120" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-120x120.png"/><link data-n-head="true" rel="apple-touch-icon" sizes="144x144" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-144x144.png"/><link data-n-head="true" rel="apple-touch-icon" sizes="152x152" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/apple-touch-icon-152x152.png"/><script data-n-head="true" data-hid="gtag-script">(function (w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
        j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
        'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
        })(window,document,'script','dataLayer','GTM-TWDXW5X');</script><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/04f171abe61a0cfc7f54.js" as="script"><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/c31e4b1262937794afa8.js" as="script"><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/b06fdd7505c2f818d0fb.js" as="script"><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/31c336f469088ffda4d5.css" as="style"><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/a564bd4b921d91e3c0b2.js" as="script"><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/31c336f469088ffda4d5.css" as="style"><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/6a4b5c7e8e0a22879fd6.js" as="script"><link rel="preload" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/af18ebb877eeec47371e.js" as="script"><link rel="stylesheet" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/31c336f469088ffda4d5.css"><link rel="stylesheet" href="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/31c336f469088ffda4d5.css">
  </head>
  <body data-n-head="">
    <div data-server-rendered="true" id="__app"><!----><div id="__layout"><div class="default"><header class="top"><div class="container"><a href="/" class="top__logo"><img src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/logo.svg" alt="TGI Smart" class="logo"></a> <a href="#" class="top__nav-toggle"><span></span></a> <nav class="top__nav"><ul><li class="top__nav-element"><a href="/">
              O usłudze
            </a></li><li class="top__nav-element"><a href="/pl/produkt">
              Produkt
            </a></li><li class="top__nav-element"><a href="/pl/cennik">
              Cennik
            </a></li><li class="top__nav-element top__nav-element--no-slash"><a href="/pl/wsparcie">
              Wsparcie
            </a></li> <li class="top__nav-button top__nav-button--right-margin"><a href="https://platform.tgismart.com/demo" class="button button--secondary">
              Wypróbuj demo
              <span class="button__badge">bezpłatnie</span></a></li> <li class="top__nav-button"><a href="https://platform.tgismart.com/buy" class="button button--tertiary">Kup pojedyncze raporty</a></li> <li class="top__nav-button"><a href="https://platform.tgismart.com/register" class="button button--primary">Kup abonament</a></li> <li class="top__nav-button"><a href="https://platform.tgismart.com/login" class="button">Zaloguj się</a></li></ul></nav></div></header> <div><div class="page"><section data-id="16" class="hero hero--text"><h1 class="hero__title">Polityka prywatności</h1> <span class="caption"><!----></span></section><section data-id="17" class="default"><div class="container"><div><p>Zgodnie z art. 13 ust. 1−2 rozporządzenia Parlamentu Europejskiego i Rady (UE) 2016/679 z 27.04.2016 r. w sprawie ochrony osób fizycznych w związku z przetwarzaniem danych osobowych i w sprawie swobodnego przepływu takich danych oraz uchylenia dyrektywy 95/46/WE (ogólne rozporządzenie o ochronie danych) (Dz.Urz. UE L 119, s. 1) – dalej RODO − informujemy, że:</p>
<h4>I. Administrator danych osobowych</h4>
<p>Konsorcjum firm Kantar Polska S.A. z siedzibą w Warszawie oraz Codeshine Sp. z o.o. z siedzibą w Warszawie jest Współadministratorem Twoich danych osobowych.</p>
<p>Adres do korespondencji: Kantar Polska S.A., pl. Konesera 9, 03-736 Warszawa, Poland</p>
<h4>II. Inspektor Ochrony Danych</h4>
<p>Wyznaczyliśmy Inspektora Ochrony Danych, z którym możesz się skontaktować w sprawach ochrony swoich danych osobowych poprzez e-mailem [<a href="mailto:kontakt@tgismart.com" title="kontakt@tgismart.com">kontakt@tgismart.com</a>]</p>
<h4>III. Cele i podstawy przetwarzania</h4>
<p>Określiliśmy cele przetwarzania Twoich danych w sposób optymalny dla Ciebie i bezpieczeństwa Twoich dancyh. Jako Współadministrator będziemy przetwarzać Twoje dane:</p>
<ol>
<li>w celu zawarcia Umowy na TGI SMART na podstawie Twojej zgody (podstawa z art. 6 ust. 1 lit. a RODO):</li>
<li>w celu wykonania i na podstawie umowy TGI SMART, jeśli ją z Nami zawrzesz (podstawa z art. 6 ust. 1 lit. b RODO);</li>
<li>w celach analitycznych: lepszego doboru usług do Twoich potrzeb, ogólnej optymalizacji naszych produktów, optymalizacji procesów obsługi, budowania wiedzy o Tobie jako naszym Kliencie, dla analizy finansowej naszych spółek, będącego realizacją naszego prawnie uzasadnionego w tym interesu (podstawa z art. 6 ust. 1 lit. f RODO);</li>
<li>w celach archiwalnych (dowodowych) będących realizacją naszego prawnie uzasadnionego interesu zabezpieczenia informacji na wypadek prawnej potrzeby wykazania faktów (art. 6 ust. 1 lit. f RODO);</li>
<li>w celu ewentualnego ustalenia, dochodzenia lub obrony przed roszczeniami będącego realizacją naszego prawnie uzasadnionego w tym interesu (podstawa z art. 6 ust. 1 lit. f RODO);</li>
<li>w celu badania satysfakcji Twojej satysfakcji oraz satysfakcji naszych Klientów, będącego realizacją naszego prawnie uzasadnionego interesu określania jakości naszej obsługi oraz poziomu zadowolenia naszych klientów z produktów i usług (podstawa z art. 6 ust. 1 lit. f RODO);</li>
<li>w celu oferowania Ci przez nas produktów i usług bezpośrednio (marketing bezpośredni), w tym dobierania ich pod kątem Twoich potrzeb, czyli profilowania, będącego realizacją naszego prawnie uzasadnionego w tym interesu (podstawa z art. 6 ust. 1 lit. f RODO);</li>
<li>W celu oferowania Ci bezpośrednio (marketing bezpośredni) produktów i usług firm z nami współpracujących (naszych partnerów), w szczególności podmiotów z naszych grup kapitałowych np. w formie kuponów rabatowych, w tym dobierania ich pod kątem Twoich potrzeb, czyli profilowania, będącego realizacją prawnie uzasadnionego w tym interesu naszego i naszych partnerów (podstawa z art. 6 ust. 1 lit. f RODO); jeśli wyraziłeś na to zgodę.</li>
</ol>
<p>W każdej chwili przysługuje Ci prawo do wycofania zgody na przetwarzanie Twoich danych osobowych, ale cofnięcie zgody nie wpływa na zgodność z prawem przetwarzania, którego dokonano na podstawie Twojej zgody przed jej wycofaniem.</p>
<h4>IV. Prawo do sprzeciwu</h4>
<ol>
<li>W każdej chwili przysługuje Ci prawo do wniesienia sprzeciwu wobec przetwarzania Twoich danych opisanych powyżej. Przestaniemy przetwarzać Twoje dane w tych celach, chyba że będziemy w stanie wykazać, że w stosunku do Twoich danych istnieją dla nas ważne prawnie uzasadnione podstawy, które są nadrzędne wobec Twoich interesów, praw i wolności lub Twoje dane będą nam niezbędne do ewentualnego ustalenia, dochodzenia lub obrony roszczeń.</li>
<li>W każdej chwili przysługuje Ci prawo do wniesienia sprzeciwu wobec przetwarzania Twoich danych w celu prowadzenia marketingu bezpośredniego. Jeżeli skorzystasz z tego prawa – zaprzestaniemy przetwarzania danych w tym celu.</li>
</ol>
<h4>V. Okres przechowywania danych</h4>
<ol>
<li>Twoje dane osobowe wynikające zawarcia umowy TGI Smart będą przetwarzane przez okres, w którym mogą ujawnić się roszczenia związane z tą umową czyli przez 3 +1 lat od końca roku, w którym wygasła Umowa TGI Smart, w tym [3] lat to najdłuższy możliwy okres przedawnienia roszczeń, a dodatkowy rok jest na wypadek roszczeń zgłoszonych w ostatniej chwili i problemów z doręczeniem, a liczenie od końca roku służy określeniu jednej daty usunięcia danych dla Umów kończących się w danym roku.</li>
<li>Jeżeli nie dojdzie do zawarcia Umowy TGI Smart w ciągu [3 dni roboczych] od dnia, w którym dokonasz rejestracji, Twoje dane osobowe związane z tą Umową zostaną niezwłocznie usunięte z wyjątkiem danych potrzebnych do marketingu bezpośredniego [zostanie zachowany wyłącznie adres e-mail].</li>
<li>Dane przetwarzane dla potrzeb marketingu bezpośredniego naszych produktów i usług możemy przetwarzać do czasu, aż zgłosisz sprzeciw względem ich przetwarzania w tym celu lub ustalimy, że się zdezaktualizowały.</li>
</ol>
<h4>VI. Odbiorcy danych</h4>
<p>Twoje dane osobowe mogą zostać ujawnione: podmiotom z grup kapitałowych członków Konsorcjum oraz naszym partnerom, czyli firmom, z którymi współpracujemy łącząc produkty lub usługi.</p>
<p>Do Twoich danych mogą też mieć dostęp nasi podwykonawcy (podmioty przetwarzające), np. firmy księgowe, prawnicze, informatyczne, likwidatorzy szkód, wykonawcy usług w ramach likwidacji szkód.</p>
<h4>VII. Prawa osób, których dane dotyczą:</h4>
<p>Zgodnie z RODO, przysługuje Ci:</p>
<ol style="list-style-type:lower-alpha;">
<li>prawo dostępu do swoich danych oraz otrzymania ich kopii;</li>
<li>prawo do sprostowania (poprawiania) swoich danych;</li>
<li>prawo do usunięcia danych, ograniczenia przetwarzania danych;</li>
<li>prawo do wniesienia sprzeciwu wobec przetwarzania danych;</li>
<li>prawo do przenoszenia danych;</li>
<li>prawo do wniesienia skargi do organu nadzorczego jakim jest Prezes Urzędu Ochrony Danych Osobowych.</li>
</ol>
<h4>VIII. Informacja o wymogu/dobrowolności podania danych</h4>
<p>Podanie danych ma charakter dobrowolny, ale jest konieczne do zawarcia i wykonywania Umowy TGI Smart.</p>
<h4>IX. Zautomatyzowane podejmowanie decyzji</h4>
<p>W procesie wykonywania Umowy TGI Smart nie będziemy podejmować decyzji w sposób zautomatyzowany.</p>
<br><br>
<h4>Informacja dotycząca plików cookies</h4>
<p>Podmiotem zamieszczającym informacje w formie plików cookies (tzw. ciasteczek) i innych podobnych technologii w urządzeniu końcowym (np. komputerze, laptopie, smartfonie, Smart TV) oraz uzyskującym do nich dostęp jest Konsorcjum firm Kantar Polska S.A. z siedzibą w Warszawie oraz Codeshine Sp. z o.o. z siedzibą w Warszawie oraz Zaufani Partnerzy.</p>
<p>Strona internetowa Platformy TGI Smart przetwarza informacje zawarte w plikach cookies. W przypadku, w którym doszłoby do zbierania danych o użytkownikach, w tym użytkownikach unikalnych, to takie dane są zbierane w sposób wyłącznie jako dane anonimowe, w postaci zbiorczej i nie obejmują danych osobowych.</p>
<p>Pliki cookies (tzw. „ciasteczka”) stanowią dane informatyczne. W szczególności są to pliki tekstowe, które przechowywane są w urządzeniu końcowym użytkownika Platformy TGI Smart i są wykorzystywane oraz służą do korzystania przez użytkownika z Platformy. Cookies zazwyczaj zawierają nazwę strony internetowej, z której pochodzą, czas przechowywania ich na urządzeniu końcowym i parametry alfanumeryczne.</p>
<p>Podmiotem zamieszczającym na urządzeniu końcowym użytkownika Platformy TGI Smart pliki cookies oraz uzyskującym do nich dostęp jest operator portalu – Codeshine Sp. z o.o. z siedzibą w Warszawie</p>
<p>Pliki cookies wykorzystywane są w następujących celach:</p>
<ol>
<li>dostosowania zawartości strony internetowej Platformy TGI Smart do preferencji użytkownika oraz optymalizacji korzystania ze stron internetowych; w szczególności pliki te pozwalają rozpoznać urządzenie użytkownika portalu i odpowiednio wyświetlić stronę internetową, dostosowaną do jego potrzeb, w zależności, czy użytkownik wyświetla stronę Platformy na urządzeniu stacjonarnym czy mobilnym.</li>
<li>tworzenia statystyk, które pomagają zrozumieć, jak użytkownicy portalu korzystają ze stron internetowych, co umożliwia ulepszanie ich struktury i zawartości.</li>
</ol>
<p>W ramach strony internetowej Platformy TGI Smart stosowane są dwa zasadnicze rodzaje plików cookies: „sesyjne” (session cookies) oraz „stałe” (persistent cookies). Cookies „sesyjne” są plikami tymczasowymi, które przechowywane są w urządzeniu końcowym użytkownika do czasu wylogowania, opuszczenia strony internetowej lub wyłączenia oprogramowania (przeglądarki internetowej). „Stałe” pliki cookies przechowywane są w urządzeniu końcowym użytkownika przez czas określony w parametrach plików cookies lub do czasu ich usunięcia przez użytkownika.</p>
<p>W ramach strony internetowej Platformy TGI Smart stosowane są następujące rodzaje plików cookies:</p>
<ol>
<li>„niezbędne” pliki cookies, umożliwiające korzystanie z usług dostępnych w ramach portalu, np. uwierzytelniające pliki cookies wykorzystywane do usług wymagających uwierzytelniania w ramach portalu,</li>
<li>pliki cookies służące do zapewnienia bezpieczeństwa, np. wykorzystywane do wykrywania nadużyć w zakresie uwierzytelniania w ramach portalu,</li>
<li>„wydajnościowe” pliki cookies, umożliwiające zbieranie informacji o sposobie korzystania ze stron internetowych portalu,</li>
<li>„funkcjonalne” pliki cookies, umożliwiające „zapamiętanie” wybranych przez użytkownika ustawień i personalizację interfejsu użytkownika, np. w zakresie wybranego języka lub regionu, z którego pochodzi użytkownik, rozmiaru czcionki, wyglądu strony internetowej itp.</li>
</ol>
<p>Operator strony internetowej Platformy TGI Smart informuje, że w celu zbierania i analizowania zagregowanych informacji o korzystaniu z portalu korzysta z usługi Google Analytics. Więcej informacji na temat zasad, na jakich usługa ta zbiera i przetwarza dane, można znaleźć w tym miejscu.</p>
<p>W wielu przypadkach oprogramowanie służące do przeglądania stron internetowych (przeglądarka internetowa) domyślnie dopuszcza przechowywanie plików cookies w urządzeniu końcowym użytkownika. Użytkownicy portalu mogą dokonać w każdym czasie zmiany ustawień dotyczących plików cookies. Ustawienia te mogą zostać zmienione w szczególności w taki sposób, aby blokować automatyczną obsługę plików cookies w ustawieniach przeglądarki internetowej, informować o ich każdorazowym zamieszczeniu w urządzeniu użytkownika portalu lub usunąć cookies zamieszczone wcześniej w urządzeniu użytkownika. Szczegółowe informacje o możliwości i sposobach obsługi plików cookies dostępne są w ustawieniach oprogramowania (przeglądarki internetowej).</p>
<p>Operator strony internetowej Platformy TGI Smart informuje, że ograniczenia stosowania plików cookies mogą wpłynąć na niektóre funkcjonalności dostępne na stronach internetowych portalu.</p>
<br><br>
<h4>Zmiany i aktualizacje Polityki prywatności</h4>
<p>Polityka prywatności może być aktualizowana, wedle uznania lub potrzeb Konsorcjum. Zaktualizowana wersja Polityki będzie publikowana niezwłocznie na stronie internetowej Platformy TGI Smart.</p>
<strong>Ostatnie zmiany: 07.09.2018 r.</strong></div></div></section></div> <footer class="bottom bottom bottom--copyrights"><div class="waving-lines"><canvas class="waving-lines__canvas"></canvas></div> <div class="container"><!----> <!----> <!----> <!----> <div class="bottom__copyrights"><div class="bottom__item"><img src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/logo-white.svg" alt="TGI Smart" class="logo bottom__logo"></div> <div class="bottom__item bottom__item--center">
        © 2021 TGI smart
        <span> | 
        <a href="https://platform.tgismart.com/contract">Regulamin Usługi</a></span><span> | 
        <a href="/pl/polityka-prywatnosci" class="link--exact-active link--active">Polityka prywatności</a></span></div> <div class="bottom__item bottom__item--right"><img src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/kantar-white.svg" alt="kantar logo" class="bottom__logo--kantar"> <img src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/codeshine-logo-white.svg" alt="codeshine logo"></div></div></div></footer></div> <div class="offline-alert" style="display:none;">
      Brak połączenia z internetem
      <a href="#" title="Zamknij" class="offline-alert__close"><img src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/img/close.svg" alt="Zamknij"></a></div> <!----> <div id="__overlay" style="display:none;"><div class="popup-form"><!----> <div class="popup-form__headline">Kontakt z doradcą</div> <form class="popup-form__form"><div class="popup-form__form-select"><select><option value="0" selected="selected">Wybierz</option> <option value="1">Producenci i usługodawcy</option><option value="2">Domy mediowe i agencje reklamowe</option><option value="3">Media</option><option value="-1">Inna / Nie wiem</option></select> <span>Należę do grupy</span> <!----></div> <div class="popup-form__form-input"><input placeholder=" "> <span>Adres e-mail</span> <!----></div> <div class="popup-form__form-select"><select><option value="0" selected="selected">Wybierz</option> <option value="4">Pytanie ogólne</option><option value="1">Pytanie merytoryczne</option><option value="2">Pytanie handlowe</option><option value="3">Pytanie techniczne</option></select> <span>Temat wiadomości</span> <!----></div> <div class="popup-form__form-textarea"><textarea placeholder=" "></textarea> <span>Treść wiadomości</span> <!----></div> <div class="form__checkbox"><input id="agreement_1" type="checkbox"> <label for="agreement_1">
        Wyrażam zgodę na przetwarzanie moich danych osobowych zamieszczonych w niniejszym formularzu przez Konsorcjum firm Kantar Polska S.A. z siedzibą w Warszawie oraz Codeshine Sp. z o.o. z siedzibą w Warszawie w celu oferowania mi produktów i usług firm współpracujących (partnerów) Konsorcjum, w szczególności podmiotów z grup kapitałowych np. w formie kuponów rabatowych, w tym dobierania ich pod kątem moich potrzeb, czyli profilowania (marketing pośredni)
      </label> <!----></div> <!----> <div class="popup-form__form-controls"><input type="submit" value="Wyślij" class="button button--primary button--big"></div></form> <a href="#" class="popup-form__close">x</a></div></div></div></div></div><script>window.__APP__=(function(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C){return {layout:e,data:[{id:11,page_id:i,name:k,slug:t,title:a,subtitle:a,content:a,active:b,position:j,main_menu:d,footer_menu:b,layout:w,locale:c,redirect_url:a,meta_title:q,meta_description:r,sections:[{id:31,section_id:s,name:k,title:h,subtitle:h,content:a,active:b,position:s,type:"hero",locale:c,additional_content:a},{id:33,section_id:C,name:"Tekst",title:h,subtitle:h,content:"\u003Cp\u003EZgodnie z art. 13 ust. 1−2 rozporządzenia Parlamentu Europejskiego i Rady (UE) 2016\u002F679 z 27.04.2016 r. w sprawie ochrony osób fizycznych w związku z przetwarzaniem danych osobowych i w sprawie swobodnego przepływu takich danych oraz uchylenia dyrektywy 95\u002F46\u002FWE (ogólne rozporządzenie o ochronie danych) (Dz.Urz. UE L 119, s. 1) – dalej RODO − informujemy, że:\u003C\u002Fp\u003E\r\n\u003Ch4\u003EI. Administrator danych osobowych\u003C\u002Fh4\u003E\r\n\u003Cp\u003EKonsorcjum firm Kantar Polska S.A. z siedzibą w Warszawie oraz Codeshine Sp. z o.o. z siedzibą w Warszawie jest Współadministratorem Twoich danych osobowych.\u003C\u002Fp\u003E\r\n\u003Cp\u003EAdres do korespondencji: Kantar Polska S.A., pl. Konesera 9, 03-736 Warszawa, Poland\u003C\u002Fp\u003E\r\n\u003Ch4\u003EII. Inspektor Ochrony Danych\u003C\u002Fh4\u003E\r\n\u003Cp\u003EWyznaczyliśmy Inspektora Ochrony Danych, z którym możesz się skontaktować w sprawach ochrony swoich danych osobowych poprzez e-mailem [\u003Ca title=\"kontakt@tgismart.com\" href=\"mailto:kontakt@tgismart.com\"\u003Ekontakt@tgismart.com\u003C\u002Fa\u003E]\u003C\u002Fp\u003E\r\n\u003Ch4\u003EIII. Cele i podstawy przetwarzania\u003C\u002Fh4\u003E\r\n\u003Cp\u003EOkreśliliśmy cele przetwarzania Twoich danych w sposób optymalny dla Ciebie i bezpieczeństwa Twoich dancyh. Jako Współadministrator będziemy przetwarzać Twoje dane:\u003C\u002Fp\u003E\r\n\u003Col\u003E\r\n\u003Cli\u003Ew celu zawarcia Umowy na TGI SMART na podstawie Twojej zgody (podstawa z art. 6 ust. 1 lit. a RODO):\u003C\u002Fli\u003E\r\n\u003Cli\u003Ew celu wykonania i na podstawie umowy TGI SMART, jeśli ją z Nami zawrzesz (podstawa z art. 6 ust. 1 lit. b RODO);\u003C\u002Fli\u003E\r\n\u003Cli\u003Ew celach analitycznych: lepszego doboru usług do Twoich potrzeb, ogólnej optymalizacji naszych produktów, optymalizacji procesów obsługi, budowania wiedzy o Tobie jako naszym Kliencie, dla analizy finansowej naszych spółek, będącego realizacją naszego prawnie uzasadnionego w tym interesu (podstawa z art. 6 ust. 1 lit. f RODO);\u003C\u002Fli\u003E\r\n\u003Cli\u003Ew celach archiwalnych (dowodowych) będących realizacją naszego prawnie uzasadnionego interesu zabezpieczenia informacji na wypadek prawnej potrzeby wykazania faktów (art. 6 ust. 1 lit. f RODO);\u003C\u002Fli\u003E\r\n\u003Cli\u003Ew celu ewentualnego ustalenia, dochodzenia lub obrony przed roszczeniami będącego realizacją naszego prawnie uzasadnionego w tym interesu (podstawa z art. 6 ust. 1 lit. f RODO);\u003C\u002Fli\u003E\r\n\u003Cli\u003Ew celu badania satysfakcji Twojej satysfakcji oraz satysfakcji naszych Klientów, będącego realizacją naszego prawnie uzasadnionego interesu określania jakości naszej obsługi oraz poziomu zadowolenia naszych klientów z produktów i usług (podstawa z art. 6 ust. 1 lit. f RODO);\u003C\u002Fli\u003E\r\n\u003Cli\u003Ew celu oferowania Ci przez nas produktów i usług bezpośrednio (marketing bezpośredni), w tym dobierania ich pod kątem Twoich potrzeb, czyli profilowania, będącego realizacją naszego prawnie uzasadnionego w tym interesu (podstawa z art. 6 ust. 1 lit. f RODO);\u003C\u002Fli\u003E\r\n\u003Cli\u003EW celu oferowania Ci bezpośrednio (marketing bezpośredni) produktów i usług firm z nami współpracujących (naszych partnerów), w szczególności podmiotów z naszych grup kapitałowych np. w formie kuponów rabatowych, w tym dobierania ich pod kątem Twoich potrzeb, czyli profilowania, będącego realizacją prawnie uzasadnionego w tym interesu naszego i naszych partnerów (podstawa z art. 6 ust. 1 lit. f RODO); jeśli wyraziłeś na to zgodę.\u003C\u002Fli\u003E\r\n\u003C\u002Fol\u003E\r\n\u003Cp\u003EW każdej chwili przysługuje Ci prawo do wycofania zgody na przetwarzanie Twoich danych osobowych, ale cofnięcie zgody nie wpływa na zgodność z prawem przetwarzania, którego dokonano na podstawie Twojej zgody przed jej wycofaniem.\u003C\u002Fp\u003E\r\n\u003Ch4\u003EIV. Prawo do sprzeciwu\u003C\u002Fh4\u003E\r\n\u003Col\u003E\r\n\u003Cli\u003EW każdej chwili przysługuje Ci prawo do wniesienia sprzeciwu wobec przetwarzania Twoich danych opisanych powyżej. Przestaniemy przetwarzać Twoje dane w tych celach, chyba że będziemy w stanie wykazać, że w stosunku do Twoich danych istnieją dla nas ważne prawnie uzasadnione podstawy, które są nadrzędne wobec Twoich interesów, praw i wolności lub Twoje dane będą nam niezbędne do ewentualnego ustalenia, dochodzenia lub obrony roszczeń.\u003C\u002Fli\u003E\r\n\u003Cli\u003EW każdej chwili przysługuje Ci prawo do wniesienia sprzeciwu wobec przetwarzania Twoich danych w celu prowadzenia marketingu bezpośredniego. Jeżeli skorzystasz z tego prawa – zaprzestaniemy przetwarzania danych w tym celu.\u003C\u002Fli\u003E\r\n\u003C\u002Fol\u003E\r\n\u003Ch4\u003EV. Okres przechowywania danych\u003C\u002Fh4\u003E\r\n\u003Col\u003E\r\n\u003Cli\u003ETwoje dane osobowe wynikające zawarcia umowy TGI Smart będą przetwarzane przez okres, w którym mogą ujawnić się roszczenia związane z tą umową czyli przez 3 +1 lat od końca roku, w którym wygasła Umowa TGI Smart, w tym [3] lat to najdłuższy możliwy okres przedawnienia roszczeń, a dodatkowy rok jest na wypadek roszczeń zgłoszonych w ostatniej chwili i problemów z doręczeniem, a liczenie od końca roku służy określeniu jednej daty usunięcia danych dla Umów kończących się w danym roku.\u003C\u002Fli\u003E\r\n\u003Cli\u003EJeżeli nie dojdzie do zawarcia Umowy TGI Smart w ciągu [3 dni roboczych] od dnia, w którym dokonasz rejestracji, Twoje dane osobowe związane z tą Umową zostaną niezwłocznie usunięte z wyjątkiem danych potrzebnych do marketingu bezpośredniego [zostanie zachowany wyłącznie adres e-mail].\u003C\u002Fli\u003E\r\n\u003Cli\u003EDane przetwarzane dla potrzeb marketingu bezpośredniego naszych produktów i usług możemy przetwarzać do czasu, aż zgłosisz sprzeciw względem ich przetwarzania w tym celu lub ustalimy, że się zdezaktualizowały.\u003C\u002Fli\u003E\r\n\u003C\u002Fol\u003E\r\n\u003Ch4\u003EVI. Odbiorcy danych\u003C\u002Fh4\u003E\r\n\u003Cp\u003ETwoje dane osobowe mogą zostać ujawnione: podmiotom z grup kapitałowych członków Konsorcjum oraz naszym partnerom, czyli firmom, z którymi współpracujemy łącząc produkty lub usługi.\u003C\u002Fp\u003E\r\n\u003Cp\u003EDo Twoich danych mogą też mieć dostęp nasi podwykonawcy (podmioty przetwarzające), np. firmy księgowe, prawnicze, informatyczne, likwidatorzy szkód, wykonawcy usług w ramach likwidacji szkód.\u003C\u002Fp\u003E\r\n\u003Ch4\u003EVII. Prawa osób, których dane dotyczą:\u003C\u002Fh4\u003E\r\n\u003Cp\u003EZgodnie z RODO, przysługuje Ci:\u003C\u002Fp\u003E\r\n\u003Col style=\"list-style-type: lower-alpha;\"\u003E\r\n\u003Cli\u003Eprawo dostępu do swoich danych oraz otrzymania ich kopii;\u003C\u002Fli\u003E\r\n\u003Cli\u003Eprawo do sprostowania (poprawiania) swoich danych;\u003C\u002Fli\u003E\r\n\u003Cli\u003Eprawo do usunięcia danych, ograniczenia przetwarzania danych;\u003C\u002Fli\u003E\r\n\u003Cli\u003Eprawo do wniesienia sprzeciwu wobec przetwarzania danych;\u003C\u002Fli\u003E\r\n\u003Cli\u003Eprawo do przenoszenia danych;\u003C\u002Fli\u003E\r\n\u003Cli\u003Eprawo do wniesienia skargi do organu nadzorczego jakim jest Prezes Urzędu Ochrony Danych Osobowych.\u003C\u002Fli\u003E\r\n\u003C\u002Fol\u003E\r\n\u003Ch4\u003EVIII. Informacja o wymogu\u002Fdobrowolności podania danych\u003C\u002Fh4\u003E\r\n\u003Cp\u003EPodanie danych ma charakter dobrowolny, ale jest konieczne do zawarcia i wykonywania Umowy TGI Smart.\u003C\u002Fp\u003E\r\n\u003Ch4\u003EIX. Zautomatyzowane podejmowanie decyzji\u003C\u002Fh4\u003E\r\n\u003Cp\u003EW procesie wykonywania Umowy TGI Smart nie będziemy podejmować decyzji w sposób zautomatyzowany.\u003C\u002Fp\u003E\r\n\u003Cbr \u002F\u003E\u003Cbr \u002F\u003E\r\n\u003Ch4\u003EInformacja dotycząca plików cookies\u003C\u002Fh4\u003E\r\n\u003Cp\u003EPodmiotem zamieszczającym informacje w formie plików cookies (tzw. ciasteczek) i innych podobnych technologii w urządzeniu końcowym (np. komputerze, laptopie, smartfonie, Smart TV) oraz uzyskującym do nich dostęp jest Konsorcjum firm Kantar Polska S.A. z siedzibą w Warszawie oraz Codeshine Sp. z o.o. z siedzibą w Warszawie oraz Zaufani Partnerzy.\u003C\u002Fp\u003E\r\n\u003Cp\u003EStrona internetowa Platformy TGI Smart przetwarza informacje zawarte w plikach cookies. W przypadku, w którym doszłoby do zbierania danych o użytkownikach, w tym użytkownikach unikalnych, to takie dane są zbierane w sposób wyłącznie jako dane anonimowe, w postaci zbiorczej i nie obejmują danych osobowych.\u003C\u002Fp\u003E\r\n\u003Cp\u003EPliki cookies (tzw. „ciasteczka”) stanowią dane informatyczne. W szczególności są to pliki tekstowe, które przechowywane są w urządzeniu końcowym użytkownika Platformy TGI Smart i są wykorzystywane oraz służą do korzystania przez użytkownika z Platformy. Cookies zazwyczaj zawierają nazwę strony internetowej, z której pochodzą, czas przechowywania ich na urządzeniu końcowym i parametry alfanumeryczne.\u003C\u002Fp\u003E\r\n\u003Cp\u003EPodmiotem zamieszczającym na urządzeniu końcowym użytkownika Platformy TGI Smart pliki cookies oraz uzyskującym do nich dostęp jest operator portalu – Codeshine Sp. z o.o. z siedzibą w Warszawie\u003C\u002Fp\u003E\r\n\u003Cp\u003EPliki cookies wykorzystywane są w następujących celach:\u003C\u002Fp\u003E\r\n\u003Col\u003E\r\n\u003Cli\u003Edostosowania zawartości strony internetowej Platformy TGI Smart do preferencji użytkownika oraz optymalizacji korzystania ze stron internetowych; w szczególności pliki te pozwalają rozpoznać urządzenie użytkownika portalu i odpowiednio wyświetlić stronę internetową, dostosowaną do jego potrzeb, w zależności, czy użytkownik wyświetla stronę Platformy na urządzeniu stacjonarnym czy mobilnym.\u003C\u002Fli\u003E\r\n\u003Cli\u003Etworzenia statystyk, które pomagają zrozumieć, jak użytkownicy portalu korzystają ze stron internetowych, co umożliwia ulepszanie ich struktury i zawartości.\u003C\u002Fli\u003E\r\n\u003C\u002Fol\u003E\r\n\u003Cp\u003EW ramach strony internetowej Platformy TGI Smart stosowane są dwa zasadnicze rodzaje plików cookies: „sesyjne” (session cookies) oraz „stałe” (persistent cookies). Cookies „sesyjne” są plikami tymczasowymi, które przechowywane są w urządzeniu końcowym użytkownika do czasu wylogowania, opuszczenia strony internetowej lub wyłączenia oprogramowania (przeglądarki internetowej). „Stałe” pliki cookies przechowywane są w urządzeniu końcowym użytkownika przez czas określony w parametrach plików cookies lub do czasu ich usunięcia przez użytkownika.\u003C\u002Fp\u003E\r\n\u003Cp\u003EW ramach strony internetowej Platformy TGI Smart stosowane są następujące rodzaje plików cookies:\u003C\u002Fp\u003E\r\n\u003Col\u003E\r\n\u003Cli\u003E„niezbędne” pliki cookies, umożliwiające korzystanie z usług dostępnych w ramach portalu, np. uwierzytelniające pliki cookies wykorzystywane do usług wymagających uwierzytelniania w ramach portalu,\u003C\u002Fli\u003E\r\n\u003Cli\u003Epliki cookies służące do zapewnienia bezpieczeństwa, np. wykorzystywane do wykrywania nadużyć w zakresie uwierzytelniania w ramach portalu,\u003C\u002Fli\u003E\r\n\u003Cli\u003E„wydajnościowe” pliki cookies, umożliwiające zbieranie informacji o sposobie korzystania ze stron internetowych portalu,\u003C\u002Fli\u003E\r\n\u003Cli\u003E„funkcjonalne” pliki cookies, umożliwiające „zapamiętanie” wybranych przez użytkownika ustawień i personalizację interfejsu użytkownika, np. w zakresie wybranego języka lub regionu, z którego pochodzi użytkownik, rozmiaru czcionki, wyglądu strony internetowej itp.\u003C\u002Fli\u003E\r\n\u003C\u002Fol\u003E\r\n\u003Cp\u003EOperator strony internetowej Platformy TGI Smart informuje, że w celu zbierania i analizowania zagregowanych informacji o korzystaniu z portalu korzysta z usługi Google Analytics. Więcej informacji na temat zasad, na jakich usługa ta zbiera i przetwarza dane, można znaleźć w tym miejscu.\u003C\u002Fp\u003E\r\n\u003Cp\u003EW wielu przypadkach oprogramowanie służące do przeglądania stron internetowych (przeglądarka internetowa) domyślnie dopuszcza przechowywanie plików cookies w urządzeniu końcowym użytkownika. Użytkownicy portalu mogą dokonać w każdym czasie zmiany ustawień dotyczących plików cookies. Ustawienia te mogą zostać zmienione w szczególności w taki sposób, aby blokować automatyczną obsługę plików cookies w ustawieniach przeglądarki internetowej, informować o ich każdorazowym zamieszczeniu w urządzeniu użytkownika portalu lub usunąć cookies zamieszczone wcześniej w urządzeniu użytkownika. Szczegółowe informacje o możliwości i sposobach obsługi plików cookies dostępne są w ustawieniach oprogramowania (przeglądarki internetowej).\u003C\u002Fp\u003E\r\n\u003Cp\u003EOperator strony internetowej Platformy TGI Smart informuje, że ograniczenia stosowania plików cookies mogą wpłynąć na niektóre funkcjonalności dostępne na stronach internetowych portalu.\u003C\u002Fp\u003E\r\n\u003Cbr \u002F\u003E\u003Cbr \u002F\u003E\r\n\u003Ch4\u003EZmiany i aktualizacje Polityki prywatności\u003C\u002Fh4\u003E\r\n\u003Cp\u003EPolityka prywatności może być aktualizowana, wedle uznania lub potrzeb Konsorcjum. Zaktualizowana wersja Polityki będzie publikowana niezwłocznie na stronie internetowej Platformy TGI Smart.\u003C\u002Fp\u003E\r\n\u003Cstrong\u003EOstatnie zmiany: 07.09.2018 r.\u003C\u002Fstrong\u003E",active:b,position:C,type:e,locale:c,additional_content:a}]}],error:a,state:{lang:c,pages:[{id:g,page_id:g,name:"O usłudze",slug:"o-usludze",title:a,subtitle:a,content:a,active:b,position:g,main_menu:b,footer_menu:d,layout:e,locale:c,redirect_url:a,meta_title:"Skuteczny Monitoring Konsumpcji Produktów i Kategorii - TGI smart",meta_description:"TGI smart to interaktywne narzędzie do analiz i wizualizacji wyników dla Twojej kategorii, marki i grupy celowej. Sprawdź, jak działamy w praktyce!"},{id:f,page_id:f,name:"Produkt",slug:"produkt",title:a,subtitle:a,content:a,active:b,position:f,main_menu:b,footer_menu:d,layout:e,locale:c,redirect_url:a,meta_title:"Produkty platformy badań i analizy rynku - TGI smart",meta_description:"Poznaj produkty i usługi analityczne dostępne na platformie TGI smart. Kompleksowa analiza grup celowych, użytkowników marek i kategorii w badaniach rynku dopasowanych do potrzeb Twojej organizacji."},{id:l,page_id:l,name:"Cennik",slug:"cennik",title:a,subtitle:a,content:a,active:b,position:m,main_menu:b,footer_menu:d,layout:e,locale:c,redirect_url:a,meta_title:"Plany taryfowe i cennik usług - TGI smart",meta_description:"Dopasuj usługę do aktualnych potrzeb informacyjnych Twojej organizacji. Sprawdź cennik planów taryfowych TGI smart w konfiguracji modułów dostosowanych do potrzeb firmy."},{id:n,page_id:n,name:"Wsparcie",slug:"wsparcie",title:a,subtitle:a,content:a,active:b,position:n,main_menu:b,footer_menu:d,layout:"default--form",locale:c,redirect_url:a,meta_title:"Wiedza i wsparcie monitoringu rynku - TGI smart",meta_description:"Najważniejsze informacje i wsparcie techniczne platformy TGI smart. Sprawdź, jak poruszać się po platformie, analizować i interpretować dane."},{id:j,page_id:j,name:"Regulamin Usługi",slug:"regulamin-uslugi",title:a,subtitle:a,content:a,active:b,position:i,main_menu:d,footer_menu:b,layout:e,locale:c,redirect_url:"https:\u002F\u002Fplatform.tgismart.com\u002Fcontract",meta_title:a,meta_description:a},{id:i,page_id:i,name:k,slug:t,title:a,subtitle:a,content:a,active:b,position:j,main_menu:d,footer_menu:b,layout:w,locale:c,redirect_url:a,meta_title:q,meta_description:r}],variables:{title:"TGI smart - Skuteczny Monitoring Konsumpcji Produktów i Kategorii",description:"TGI smart to interaktywne narzędzie do analiz i wizualizacji wyników dla Twojej kategorii, marki i grupy celowej",keywords:a,"platform-link":"https:\u002F\u002Fplatform.tgismart.com","ga-id":"UA-125568411-1","button-play":u,"button-pricing":"Sprawdź plany","button-discover-product":"Poznaj możliwości","button-check-out":"Sprawdź dostępne szablony analiz","button-discover-data":"Poznaj nasze dane",responses:"300000000","responses-text":"Ponad 300 milionów odpowiedzi respondentów w naszej bazie","button-inquiry":"Zapytaj doradcę","button-details":"Pokaż szczegóły","report-group":"Szablony raportów",previous:"Poprzedni",next:"Następny","button-register":u,"button-login":"Zaloguj się","button-contact":v,sending:"Wysyłanie...",footer:"© 2021 TGI smart","footer-form-headline":"Kontakt","footer-form-title":"Nasz ekspert jest do Twojej dyspozycji!","footer-headline":"Zamów","footer-title":"Zarejestruj się i zamów swój abonament","footer-form-name":"Twoje imię","footer-form-name-error":"Pole Twoje imię jest wymagane.","footer-form-company":"Nazwa firmy","footer-form-company-error":"Pole Nazwa firmy jest wymagane.","footer-form-email":o,"footer-form-email-error":p,"footer-form-email-format-error":"Format pola Adres e-mail jest nieprawidłowy.","footer-form-phone":"Nr tel.","footer-form-phone-error":"Pole Nr tel. jest wymagane.","footer-form-success-text":y,"popup-form-headline":"Kontakt z doradcą","popup-form-type":"Należę do grupy","popup-form-email":o,"popup-form-email-error":p,"popup-form-email-format-error":z,"popup-form-subject":"Temat wiadomości","popup-form-content":"Treść wiadomości","popup-form-content-error":"Pole Treść wiadomości jest wymagane.","popup-form-send":A,"popup-form-success-text":y,"hero-data-categories":"250","hero-data-categories-text":"Kategorii produktowych","hero-data-brands":"4600","hero-data-brands-text":"Monitorowanych marek","hero-data-year":"1998","hero-data-year-text":"start ciągłego monitoringu i&nbsp;zbierania danych w Polsce","hero-data-respondents":"1700","hero-data-respondents-text":"Respondentów miesięcznie","hero-data-interviews":"20000","hero-data-interviews-text":"Wywiadów rocznie","hero-data-people":"700000","hero-data-people-text":"zrealizowanych wywiadów","target-groups-visual-text":"GRUPA CELOWA","gi-data-respondent":"Respondent","gi-data-respondent-text":"Pomiar indywidualnych aktywności respondenta","gi-data-household":"Gospodarstwo domowe","gi-data-household-text":"Pomiar aktywności odnoszących się do całego gospodarstwa domowego","data-categories":"Sektory","data-subcategories":"Kategorie szczegółowe",categories:"kategoria,kategorie,kategorii","price-table-recommended":"Rekomendowany","price-table-select":"Wybieram","404-headline":"Error 404","404-title":"Strona nie istnieje","404-text":"Czy wiesz, że statystyki pokazują, iż 2% odnośników w internecie\u003Cbr\u003Ejest nieaktualnych i prowadzi do nieistniejących stron?","404-button":"Poinformuj naszego administratora o tym, jak tu trafiłeś.","admin-email":"admin@tgismart.com","alert-target-date":"1539630000000","alert-days":"dni","alert-title":"Platforma startuje 15.10.2018","alert-subtitle":"Pozostaw nam kontakt do siebie a przypomnimy Ci o terminie premiery","alert-form-email":o,"alert-form-send":A,"alert-form-email-error":p,"alert-form-email-format-error":z,availability:"Dostępny w","alert-hours":"godz.","alert-minutes":"min.","new-contact-notification-email":"arkadiusz.kalemba@codeshine.io","popup-form-choose":"Wybierz","popup-form-type-error":"Pole Należę do grupy jest wymagane.","popup-form-subject-error":"Pole Temat wiadomości jest wymagane.","report-groups-numbering":a,"price-table-plan":"Plan taryfowy",close:"Zamknij","button-demo":"Wypróbuj demo","link-demo":"https:\u002F\u002Fplatform.tgismart.com\u002Fdemo","form-agreement-1":"Wyrażam zgodę na przetwarzanie moich danych osobowych zamieszczonych w niniejszym formularzu przez Konsorcjum firm Kantar Polska S.A. z siedzibą w Warszawie oraz Codeshine Sp. z o.o. z siedzibą w Warszawie w celu oferowania mi produktów i usług firm współpracujących (partnerów) Konsorcjum, w szczególności podmiotów z grup kapitałowych np. w formie kuponów rabatowych, w tym dobierania ich pod kątem moich potrzeb, czyli profilowania (marketing pośredni)","form-agreement-2":"Wyrażam zgodę na przesyłanie mi informacji o nowych produktach Konsorcjum, aktualizacjach, ofertach specjalnych, promocjach oraz informacjach marketingowych przez Konsorcjum firm Kantar Polska S.A. z siedzibą w Warszawie oraz Codeshine Sp. z o.o. z siedzibą w Warszawie (podstawa z art. 10 ust. 2 ustawy o świadczeniu usług drogą elektroniczną)","form-agreement-error":"Pole musi zostać zaakceptowane.","button-demo-free":"bezpłatnie","button-example-pdf":"Przykładowy raport (PDF)","help-search":"Jak możemy Ci pomóc? Wyszukaj zagadnienie","help-search-hint":B,"help-search-no-results":x,"brands-search":"Wpisz jakiej marki lub kategorii produktowej szukasz...","brands-search-no-results":x,"brands-available-dashboards":"Dostępne szablony raportów:","brands-info-text":"Znaleziono","brands-info-text-variants":"kategorię produktową,kategorie produktowe,kategorii produktowych","brands-contact-info":"Nasz ekspert jest do Twojej dyspozycji","brands-contact-button":v,"brands-search-hint":B,"503-headline":"Error 503","503-title":"Błąd połączenia","500-headline":"Error 500","500-title":"Nieznany błąd","offline-alert":"Brak połączenia z internetem","hero-data-statistics-title":"Badania rynku Smart w liczbach","button-buy-link":"https:\u002F\u002Fplatform.tgismart.com\u002Fbuy","button-buy-label":"Kup pojedyncze raporty","monitoring-download-report-pl":"Pobierz raport (PL)","monitoring-download-report-en":"Download report (EN)"},showPopup:d,popupType:0,inquirySubjects:[{id:l,name:"Pytanie ogólne"},{id:g,name:"Pytanie merytoryczne"},{id:f,name:"Pytanie handlowe"},{id:m,name:"Pytanie techniczne"}],inquiryTypes:[{id:g,name:"Producenci i usługodawcy"},{id:f,name:"Domy mediowe i agencje reklamowe"},{id:m,name:"Media"},{id:-1,name:"Inna \u002F Nie wiem"}]},serverRendered:b}}(null,true,"pl",false,"default",2,1,"",6,7,"Polityka prywatności",4,3,5,"Adres e-mail","Pole Adres e-mail jest wymagane.","Polityka prywatności - TGI smart","Polityka prywatności platformy TGI smart",16,"polityka-prywatnosci","Kup abonament","Zapytaj eksperta","default--copyrights","Brak wyników","Dziękujemy za wiadomość. Wkrótce nasz przedstawiciel skontaktuje się z Panem\u002FPanią.","Format Adres e-mail jest nieprawidłowy.","Wyślij","Wpisz co najmniej 2 znaki",17));</script><script src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/04f171abe61a0cfc7f54.js" defer></script><script src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/6a4b5c7e8e0a22879fd6.js" defer></script><script src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/af18ebb877eeec47371e.js" defer></script><script src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/c31e4b1262937794afa8.js" defer></script><script src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/b06fdd7505c2f818d0fb.js" defer></script><script src="https://s3.eu-central-1.amazonaws.com/tgismart-website-assets/a564bd4b921d91e3c0b2.js" defer></script><noscript data-n-head="true" data-hid="gtag-noscript" data-body="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TWDXW5X"
        height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
  </body>
</html>
