window.nitroFragments['caca11f328c510ea748bb7953bf7d7e1'] = {"isLazyLoaded":true,"content":"<div id='av_section_4' class="avia-section av-dhy9aj8-d4aaece49a4ffaeecfb79e56512e5b98 main_color avia-section-huge avia-no-border-styling avia-builder-el-37 el_after_av_section el_before_av_section avia-bg-style-fixed container_wrap fullsize nitro-lazy-render" nitro-fragment-parent><div class='container av-section-cont-open'><div class='template-page content  av-content-full alpha units'><div class='post-entry post-entry-type-page post-entry-35860'><div class='entry-content-wrapper clearfix'> <div class='hr av-lkh4knuk-17b9fb07481c6eebef201d9e614b6102 hr-invisible  avia-builder-el-38  el_before_av_textblock  avia-builder-el-first'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <section class='av_textblock_section av-lkh363b9-c3ab5ee28f06067bc7b2b4b1814f8da9'><div class='avia_textblock av_inherit_color'><h2 style="text-align:center;" id="dmarc-api-features"><strong>Caratteristiche dell'API DMARC</strong></h2> </div></section> <div class='hr av-d89da1g-9f1eab197a23fd9c25e033a72831d55f hr-invisible  avia-builder-el-40  el_after_av_textblock  el_before_av_one_half'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <div class='flex_column av-cm5h0k4-a21ac7f2dddcab0bbfb97edad1779522 av_one_half  avia-builder-el-41  el_after_av_hr  el_before_av_one_half  first flex_column_div shadow-not-animated'><section class='av_textblock_section av-lkh36l1d-fd38e1b20c79e1c3aef4cd1a708bc4ad'><div class='avia_textblock'><h3 id="dmarc-record-generator-api"><strong>API generatore di record DMARC</strong></h3> </div></section> <section class='av_textblock_section av-lkh37h16-ef99895966e7f355940721c388ed8ceb'><div class='avia_textblock'><p><img alt="" width="120" height="82" title="DMARC API for Your Applications" sizes="(max-width: 120px) 100vw, 120px" nitro-lazy-srcset="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-generator-API.png 320w, https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-generator-API-300x205.png 300w" nitro-lazy-src="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-generator-API.png" class="alignnone wp-image-49454 nitro-lazy" decoding="async" nitro-lazy-empty id="MTI4Mzo1NjM=-1" src="data:image/svg+xml;nitro-empty-id=MTI4Mzo1NjM=-1;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzIwIDIxOSIgd2lkdGg9IjMyMCIgaGVpZ2h0PSIyMTkiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PC9zdmc+" /></p> <p style="text-align:left;"><strong>Sfruttate il nostro generatore di <a id="link_juicer" href="https://powerdmarc.com/it/how-to-publish-a-dmarc-record/" data-wpel-link="internal" target="_self" rel="follow">record DMARC</a> API per semplificare la creazione di record DMARC, automatizzandola e garantendo coerenza e accuratezza.</strong></p> </div></section> <div class='hr av-lkh397yr-37de45a66fa9e7ea1536794fe95ff2a3 hr-default  avia-builder-el-44  el_after_av_textblock  el_before_av_textblock'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <section class='av_textblock_section av-lkh38ghu-95feda3b0167ffb71925d1db80c003d7'><div class='avia_textblock'><h4 id="endpoint-description">Descrizione del punto finale</h4> <p style="text-align:left;"><span style="font-weight:400;">In base ai dati forniti, l'endpoint genera il record DMARC. Il numero massimo di record DMARC che possono essere generati è 10.</span></p> <p><strong><a href="https://api.powerdmarc.com/#c1b926d0-1de8-44bb-8113-53dafeef788d" data-wpel-link="external" target="_blank">Documentazione sulla generazione di record DMARC</a></strong></p> </div></section> <div class='hr av-cczzqdw-10388d650a35e7bb9f1133606f2b665f hr-invisible  avia-builder-el-46  el_after_av_textblock  avia-builder-el-last'><span class='hr-inner'><span class="hr-inner-style"></span></span></div></div><div class='flex_column av-bmlu22c-dbc44e9db360c7dbe9e4caca63053e80 av_one_half  avia-builder-el-47  el_after_av_one_half  el_before_av_one_half  flex_column_div shadow-not-animated'><section class='av_textblock_section av-lkh3e0jf-11e5021383fe1a259e2bf6fa4920bdc1'><div class='avia_textblock'><h3 id="dmarc-record-lookup-api"><strong>API di ricerca dei record DMARC</strong></h3> </div></section> <section class='av_textblock_section av-lkh3eebs-255fb7b5e64a2be300c671d04d13e5e0'><div class='avia_textblock'><p><img alt="" width="120" height="82" title="DMARC API for Your Applications" sizes="(max-width: 120px) 100vw, 120px" nitro-lazy-srcset="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-Lookup-API.png 320w, https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-Lookup-API-300x205.png 300w" nitro-lazy-src="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-Lookup-API.png" class="alignnone wp-image-49455 nitro-lazy" decoding="async" nitro-lazy-empty id="MTI5Mzo1NTQ=-1" src="data:image/svg+xml;nitro-empty-id=MTI5Mzo1NTQ=-1;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzIwIDIxOSIgd2lkdGg9IjMyMCIgaGVpZ2h0PSIyMTkiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PC9zdmc+" /></p> <p style="text-align:left;"><strong>La nostra API per la ricerca dei record DMARC offre alle organizzazioni la possibilità di recuperare e analizzare rapidamente e facilmente i record DMARC per qualsiasi dominio.</strong></p> </div></section> <div class='hr av-b7tzjdg-5efbb79504d98cbb6d929320bdb3b383 hr-default  avia-builder-el-50  el_after_av_textblock  el_before_av_textblock'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <section class='av_textblock_section av-lkh3ep8m-eacfed8d64fba2a4bab1993f02113fb3'><div class='avia_textblock'><h4 id="endpoint-description">Descrizione del punto finale</h4> <p style="text-align:left;"><span style="font-weight:400;">L'endpoint restituisce il record DMARC per il dominio o i domini specificati. Il numero massimo di domini che è possibile fornire è 10.</span></p> <p><strong><a href="https://api.powerdmarc.com/#c45bf526-2d18-48b0-8c50-b3630b7d23b5" data-wpel-link="external" target="_blank">Documentazione sulla ricerca dei record DMARC</a></strong></p> </div></section> <div class='hr av-aoe6mxg-15db5840bd2ccde176a922b565c4ac1f hr-invisible  avia-builder-el-52  el_after_av_textblock  avia-builder-el-last'><span class='hr-inner'><span class="hr-inner-style"></span></span></div></div><div class='flex_column av-ajn0iic-8602e3fbf35f9a938009cef0ad18cae2 av_one_half  avia-builder-el-53  el_after_av_one_half  el_before_av_one_half  first flex_column_div shadow-not-animated  column-top-margin'><section class='av_textblock_section av-lkh3ft01-e0559472c7a63bcc8ad51e73665ce4f5'><div class='avia_textblock'><h3 id="dmarc-aggregate-report-api"><strong>Rapporto aggregato DMARC API</strong></h3> </div></section> <section class='av_textblock_section av-lkh3gadz-35ab9a9474bb2121a301491263e603fb'><div class='avia_textblock'><p><img alt="" width="120" height="82" title="DMARC API for Your Applications" sizes="(max-width: 120px) 100vw, 120px" nitro-lazy-srcset="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-Aggregate-Report-API.png 320w, https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-Aggregate-Report-API-300x205.png 300w" nitro-lazy-src="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-Aggregate-Report-API.png" class="alignnone wp-image-49456 nitro-lazy" decoding="async" nitro-lazy-empty id="MTMwMzo1NjM=-1" src="data:image/svg+xml;nitro-empty-id=MTMwMzo1NjM=-1;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzIwIDIxOSIgd2lkdGg9IjMyMCIgaGVpZ2h0PSIyMTkiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PC9zdmc+" /></p> <p style="text-align:left;"><strong>Invece di ricevere e analizzare manualmente i rapporti, l'API consente il recupero e l'elaborazione automatica dei dati, rendendo più conveniente la distribuzione su larga scala e il monitoraggio in tempo reale in 7 diverse visualizzazioni (per fonte di invio, risultato, organizzazione, host, statistiche dettagliate, paese, geolocalizzazione).</strong></p> </div></section> <div class='hr av-9xm19w4-d9b2da4790f212b8fee06451a3107d43 hr-default  avia-builder-el-56  el_after_av_textblock  el_before_av_textblock'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <section class='av_textblock_section av-lkh3gpox-85fae8be7720249d20a5ee5bd3616680'><div class='avia_textblock'><h4 id="endpoint-description">Descrizione del punto finale</h4> <p><span style="font-weight:400;">L'endpoint è indicato per ottenere i rapporti DMARC Aggregate.&nbsp;</span></p> <p><strong><a href="https://api.powerdmarc.com/#abcdba5d-0665-44ab-943f-a865cd6aa9de" data-wpel-link="external" target="_blank">Documentazione dei rapporti aggregati DMARC</a></strong></p> </div></section> <div class='hr av-995h66s-c3855a1a38ba3a2514bf945ce2b383e9 hr-invisible  avia-builder-el-58  el_after_av_textblock  avia-builder-el-last'><span class='hr-inner'><span class="hr-inner-style"></span></span></div></div><div class='flex_column av-95870c4-2e2cb43a82d5534b05df9d88318aa27b av_one_half  avia-builder-el-59  el_after_av_one_half  el_before_av_one_half  flex_column_div shadow-not-animated  column-top-margin'><section class='av_textblock_section av-lkh3hb6e-79e6fba4344ae5b4c2c97105931bdd34'><div class='avia_textblock'><h3 id="dmarc-forensic-report-api"><strong>Rapporto forense DMARC API</strong></h3> </div></section> <section class='av_textblock_section av-lkh3hnwk-4c0e78498825146c214c4e25f153cbd0'><div class='avia_textblock'><p><img alt="" width="120" height="82" title="DMARC API for Your Applications" sizes="(max-width: 120px) 100vw, 120px" nitro-lazy-srcset="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-Forensic-Report-API.png 320w, https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-Forensic-Report-API-300x205.png 300w" nitro-lazy-src="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-Forensic-Report-API.png" class="alignnone wp-image-49457 nitro-lazy" decoding="async" nitro-lazy-empty id="MTMxMzo1NjA=-1" src="data:image/svg+xml;nitro-empty-id=MTMxMzo1NjA=-1;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzIwIDIxOSIgd2lkdGg9IjMyMCIgaGVpZ2h0PSIyMTkiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PC9zdmc+" /></p> <p style="text-align:left;"><strong>L'API per i rapporti forensi DMARC consente ai proprietari di domini di automatizzare il recupero e l'elaborazione di questi rapporti forensi, invece di accedere manualmente e analizzare i singoli rapporti. È utile per le organizzazioni che gestiscono un grande volume di traffico e-mail e che desiderano monitorare l'<a id="link_juicer" href="https://powerdmarc.com/it/how-to-implement-dmarc/" data-wpel-link="internal" target="_self" rel="follow">implementazione del DMARC</a> e la <a id="link_juicer" href="https://powerdmarc.com/it/what-is-email-security/" data-wpel-link="internal" target="_self" rel="follow">sicurezza delle e-mail</a> in modo più efficiente.</strong></p> </div></section> <div class='hr av-v2o46s-eeee45b5b22de19cd55638db46d9a115 hr-default  avia-builder-el-62  el_after_av_textblock  el_before_av_textblock'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <section class='av_textblock_section av-lkh3i3bl-49533793a7ef23aea059325c560cf579'><div class='avia_textblock'><h4 id="endpoint-description">Descrizione del punto finale</h4> <p><span style="font-weight:400;">L'endpoint recupera i dettagli e i dati dei rapporti forensi.&nbsp;</span></p> <p><strong><a href="https://api.powerdmarc.com/#e46105c8-97f3-4ed3-bd48-18b7bfc63457" data-wpel-link="external" target="_blank">Documentazione del rapporto forense DMARC</a></strong></p> </div></section> <div class='hr av-7wzqwlw-55abca129c5c36bee1f3b9ad7c446c02 hr-invisible  avia-builder-el-64  el_after_av_textblock  avia-builder-el-last'><span class='hr-inner'><span class="hr-inner-style"></span></span></div></div><div class='flex_column av-7p5jfv8-e2553faca4eb6fe0e8eb647a25e86a0d av_one_half  avia-builder-el-65  el_after_av_one_half  el_before_av_hr  first flex_column_div shadow-not-animated  column-top-margin'><section class='av_textblock_section av-lkh3ig79-5e937065a3d17d65691961328159427c'><div class='avia_textblock'><h3 id="dmarc-record-management-api"><strong>API per la gestione dei record DMARC</strong></h3> </div></section> <section class='av_textblock_section av-lkh3isj5-57d254bdf602261634013ed0c9ef71ce'><div class='avia_textblock'><p><img alt="" width="120" height="82" title="DMARC API for Your Applications" sizes="(max-width: 120px) 100vw, 120px" nitro-lazy-srcset="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-management-API.png 320w, https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-management-API-300x205.png 300w" nitro-lazy-src="https://cdn-caklk.nitrocdn.com/sJCpruYkVvovUsWvtAEzkQwTuXjDDQLL/assets/images/optimized/rev-1ef354f/powerdmarc.com/wp-content/uploads/2023/07/DMARC-record-management-API.png" class="alignnone wp-image-49458 nitro-lazy" decoding="async" nitro-lazy-empty id="MTMyMzo1NjY=-1" src="data:image/svg+xml;nitro-empty-id=MTMyMzo1NjY=-1;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzIwIDIxOSIgd2lkdGg9IjMyMCIgaGVpZ2h0PSIyMTkiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PC9zdmc+" /></p> <p style="text-align:left;"><strong>La nostra API per <a id="link_juicer" href="https://powerdmarc.com/it/benefits-of-dmarc-management/" data-wpel-link="internal" target="_self" rel="follow">la gestione dei record DMARC</a> offre un modo pratico per automatizzare la creazione, la modifica e l'eliminazione dei record DMARC. L'API consente una gestione semplificata delle <a id="link_juicer" href="https://powerdmarc.com/it/google-calendar-responses-and-dmarc/" data-wpel-link="internal" target="_self" rel="follow">impostazioni DMARC</a>, facilitando l'implementazione e la manutenzione delle misure di autenticazione e protezione delle e-mail.</strong></p> </div></section> <div class='hr av-7bfdnro-c66cc6e03fba47ccb6a6576490a5edea hr-default  avia-builder-el-68  el_after_av_textblock  el_before_av_textblock'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <section class='av_textblock_section av-lkh3j8gx-28037b5972ae6d0b3310fd8f58d350d1'><div class='avia_textblock'><h4 id="endpoint-description">Descrizione del punto finale</h4> <p><span style="font-weight:400;">Gli endpoint API DMARC includono funzionalità quali il recupero di record DMARC, la creazione di nuovi record DMARC, l'aggiornamento di record esistenti, l'eliminazione di record o il recupero di report e statistiche relative all'autenticazione DMARC.</span></p> </div></section> <div class='hr av-6uiq81g-c3814481539ba0b7ddd32c7327ac88c4 hr-invisible  avia-builder-el-70  el_after_av_textblock  avia-builder-el-last'><span class='hr-inner'><span class="hr-inner-style"></span></span></div></div><div class='hr av-lkh50xtr-e7c9fcf501216566b03502660dc7b6f0 hr-invisible  avia-builder-el-71  el_after_av_one_half  avia-builder-el-last'><span class='hr-inner'><span class="hr-inner-style"></span></span></div> <p></p> </div></div></div></div></div>"};
window.dispatchEvent(new CustomEvent('nitrofragmentloaded', {detail: "caca11f328c510ea748bb7953bf7d7e1"}));