<!-- vcwb/dynamicElementComment:e12310fc -->
<div class="vce-row-container" data-vce-boxed-width="true">
<div id="el-e12310fc" class="vce-row vce-row--col-gap-30 vce-row-equal-height vce-row-content--top" data-vce-do-apply="all el-e12310fc">
<div class="vce-row-content" data-vce-element-content="true"><!-- vcwb/dynamicElementComment:3d2d2f24 -->
<div id="el-3d2d2f24" class="vce-col vce-col--md-auto vce-col--xs-1 vce-col--xs-last vce-col--xs-first vce-col--sm-last vce-col--sm-first vce-col--md-last vce-col--lg-last vce-col--xl-last vce-col--md-first vce-col--lg-first vce-col--xl-first">
<div class="vce-col-inner" data-vce-do-apply="border margin background  el-3d2d2f24">
<div class="vce-col-content" data-vce-element-content="true" data-vce-do-apply="padding el-3d2d2f24"><!-- vcwb/dynamicElementComment:c65cd6f4 -->
<div class="vce-text-block">
<div id="el-c65cd6f4" class="vce-text-block-wrapper vce" data-vce-do-apply="all el-c65cd6f4"><div class="wp-block-ub-content-toggle wp-block-ub-content-toggle-block" id="ub-content-toggle-block-26a0f004-2b40-452e-874e-005ec917e124" data-mobilecollapse="true" data-desktopcollapse="true" data-preventcollapse="false" data-showonlyone="false">

<div class="wp-block-ub-content-toggle-accordion" style="border-color: #fff; border-top-left-radius: 8px; border-top-right-radius: 8px; border-bottom-left-radius: 8px; border-bottom-right-radius: 8px; " id="ub-content-toggle-panel-block-">
			<div class="wp-block-ub-content-toggle-accordion-title-wrap" style="background-color: #fff;" aria-controls="ub-content-toggle-panel-0-26a0f004-2b40-452e-874e-005ec917e124" tabindex="0">
			<h2 class="wp-block-ub-content-toggle-accordion-title ub-content-toggle-title-26a0f004-2b40-452e-874e-005ec917e124" style="color: #000000; ">Associati</h2>
			<div class="wp-block-ub-content-toggle-accordion-toggle-wrap right" style="color: #000000;"><span class="wp-block-ub-content-toggle-accordion-state-indicator wp-block-ub-chevron-down"></span></div>
		</div>
			<div role="region" aria-expanded="false" class="wp-block-ub-content-toggle-accordion-content-wrap ub-hide" id="ub-content-toggle-panel-0-26a0f004-2b40-452e-874e-005ec917e124">


<p class="wp-block-paragraph">Se ti interessa <strong>realizzare la vision</strong> di Vitality impresa sociale insieme a noi, <strong>leggi lo Statuto</strong> e <strong>compila il form sottostante</strong>.</p>



<div class="wp-block-file"><a id="wp-block-file--media-2ed65005-bd98-4363-800e-a832df75e1d6" href="https://www.vitalitysocial.it/wp-content/uploads/2025/02/Vitality-Impresa-Sociale_Statuto.pdf">Vitality-Impresa-Sociale_Statuto</a><a class="wp-block-file__button wp-element-button" href="https://www.vitalitysocial.it/wp-content/uploads/2025/02/Vitality-Impresa-Sociale_Statuto.pdf" download="" aria-describedby="wp-block-file--media-2ed65005-bd98-4363-800e-a832df75e1d6">Download</a></div>


<div class="wpforms-container wpforms-container-full wpforms-block wpforms-block-99679597-1abb-4f86-8230-f10ba9fbb386 wpforms-render-modern" id="wpforms-3758"><form id="wpforms-form-3758" class="wpforms-validate wpforms-form wpforms-ajax-form" data-formid="3758" method="post" enctype="multipart/form-data" action="/collabora/sostegno" data-token="46b4f3023c9bde06b6bc19fa035cf5c4" data-token-time="1791497849"><noscript class="wpforms-error-noscript">Abilita JavaScript nel browser per completare questo modulo.</noscript><div id="wpforms-error-noscript" style="display: none;">Abilita JavaScript nel browser per completare questo modulo.</div><div class="wpforms-field-container"><div id="wpforms-3758-field_3-container" class="wpforms-field wpforms-field-name" data-field-id="3"><fieldset><legend class="wpforms-field-label">Nome <span class="wpforms-required-label" aria-hidden="true">*</span></legend><div class="wpforms-field-row wpforms-field-medium"><div class="wpforms-field-row-block wpforms-first wpforms-one-half"><input type="text" id="wpforms-3758-field_3" class="wpforms-field-name-first wpforms-field-required" name="wpforms[fields][3][first]" aria-errormessage="wpforms-3758-field_3-error" required><label for="wpforms-3758-field_3" class="wpforms-field-sublabel after">Nome</label></div><div class="wpforms-field-row-block wpforms-one-half"><input type="text" id="wpforms-3758-field_3-last" class="wpforms-field-name-last wpforms-field-required" name="wpforms[fields][3][last]" aria-errormessage="wpforms-3758-field_3-last-error" required><label for="wpforms-3758-field_3-last" class="wpforms-field-sublabel after">Cognome</label></div></div></fieldset></div><div id="wpforms-3758-field_1-container" class="wpforms-field wpforms-field-text" data-field-id="1"><label class="wpforms-field-label" for="wpforms-3758-field_1">Indirizzo / Cap / Città <span class="wpforms-required-label" aria-hidden="true">*</span></label><input type="text" id="wpforms-3758-field_1" class="wpforms-field-medium wpforms-field-required" name="wpforms[fields][1]" aria-errormessage="wpforms-3758-field_1-error" required></div><div id="wpforms-3758-field_5-container" class="wpforms-field wpforms-field-email" data-field-id="5"><label class="wpforms-field-label" for="wpforms-3758-field_5">Email <span class="wpforms-required-label" aria-hidden="true">*</span></label><input type="email" id="wpforms-3758-field_5" class="wpforms-field-medium wpforms-field-required" name="wpforms[fields][5]" spellcheck="false" aria-errormessage="wpforms-3758-field_5-error" required></div><div id="wpforms-3758-field_2-container" class="wpforms-field wpforms-field-text" data-field-id="2"><label class="wpforms-field-label" for="wpforms-3758-field_2">Codice fiscale <span class="wpforms-required-label" aria-hidden="true">*</span></label><input type="text" id="wpforms-3758-field_2" class="wpforms-field-medium wpforms-field-required" name="wpforms[fields][2]" aria-errormessage="wpforms-3758-field_2-error" required></div>		<div id="wpforms-3758-field_6-container" class="wpforms-field wpforms-field-text" data-field-type="text" data-field-id="6">
			<label class="wpforms-field-label" for="wpforms-3758-field_6">Ho Email fiscale</label>
			<input type="text" id="wpforms-3758-field_6" class="wpforms-field-medium" name="wpforms[fields][6]">
		</div>
		<div id="wpforms-3758-field_7-container" class="wpforms-field wpforms-field-checkbox" data-field-id="7"><fieldset><legend class="wpforms-field-label">Ho preso visione dello statuto di Vitality Impresa Sociale</legend><ul id="wpforms-3758-field_7"><li class="choice-1 depth-1"><input type="checkbox" id="wpforms-3758-field_7_1" name="wpforms[fields][7][]" value="Accetto e condivido" aria-errormessage="wpforms-3758-field_7_1-error"><label class="wpforms-field-label-inline" for="wpforms-3758-field_7_1">Accetto e condivido</label></li><li class="choice-4 depth-1"><input type="checkbox" id="wpforms-3758-field_7_4" name="wpforms[fields][7][]" value="Desidero approfondimenti" aria-errormessage="wpforms-3758-field_7_4-error"><label class="wpforms-field-label-inline" for="wpforms-3758-field_7_4">Desidero approfondimenti</label></li><li class="choice-5 depth-1"><input type="checkbox" id="wpforms-3758-field_7_5" name="wpforms[fields][7][]" value="Esprimo delle riserve" aria-errormessage="wpforms-3758-field_7_5-error"><label class="wpforms-field-label-inline" for="wpforms-3758-field_7_5">Esprimo delle riserve</label></li></ul></fieldset></div><div id="wpforms-3758-field_8-container" class="wpforms-field wpforms-field-checkbox" data-field-id="8"><fieldset><legend class="wpforms-field-label">Ho versato la quota associativa 2025 di 25 euro (cfr. Dona) tramite</legend><ul id="wpforms-3758-field_8"><li class="choice-1 depth-1"><input type="checkbox" id="wpforms-3758-field_8_1" name="wpforms[fields][8][]" value="Carta di credito" aria-errormessage="wpforms-3758-field_8_1-error"><label class="wpforms-field-label-inline" for="wpforms-3758-field_8_1">Carta di credito</label></li><li class="choice-2 depth-1"><input type="checkbox" id="wpforms-3758-field_8_2" name="wpforms[fields][8][]" value="Bonifico bancario" aria-errormessage="wpforms-3758-field_8_2-error"><label class="wpforms-field-label-inline" for="wpforms-3758-field_8_2">Bonifico bancario</label></li><li class="choice-3 depth-1"><input type="checkbox" id="wpforms-3758-field_8_3" name="wpforms[fields][8][]" value="PayPal" aria-errormessage="wpforms-3758-field_8_3-error"><label class="wpforms-field-label-inline" for="wpforms-3758-field_8_3">PayPal</label></li></ul></fieldset></div><div id="wpforms-3758-field_4-container" class="wpforms-field wpforms-field-textarea" data-field-id="4"><label class="wpforms-field-label" for="wpforms-3758-field_4">Lascia un messaggio</label><textarea id="wpforms-3758-field_4" class="wpforms-field-medium" name="wpforms[fields][4]" aria-errormessage="wpforms-3758-field_4-error"></textarea></div><script>
				( function() {
					const style = document.createElement( 'style' );
					style.appendChild( document.createTextNode( '#wpforms-3758-field_6-container,#wpforms-3773-field_6-container { position: absolute !important; overflow: hidden !important; display: inline !important; height: 1px !important; width: 1px !important; z-index: -1000 !important; padding: 0 !important; } #wpforms-3758-field_6-container,#wpforms-3773-field_6-container input { visibility: hidden; } #wpforms-conversational-form-page #wpforms-3758-field_6-container,#wpforms-3773-field_6-container label { counter-increment: none; }' ) );
					document.head.appendChild( style );
					document.currentScript?.remove();
				} )();
			</script></div><!-- .wpforms-field-container --><div class="wpforms-submit-container"><input type="hidden" name="wpforms[id]" value="3758"><input type="hidden" name="wpforms[time_token]" value="1791497849.59ff6e5851084b8488fb67dd4a8c6ced746b54c7e8dfff9f299145e2e62cfe21"><input type="hidden" name="page_title" value="Collabora"><input type="hidden" name="page_url" value="https://www.vitalitysocial.it/collabora/sostegno"><input type="hidden" name="url_referer" value=""><input type="hidden" name="page_id" value="2510"><input type="hidden" name="wpforms[post_id]" value="2510"><button type="submit" name="wpforms[submit]" id="wpforms-submit-3758" class="wpforms-submit" data-alt-text="Invio in corso..." data-submit-text="Invia" aria-live="assertive" value="wpforms-submit">Invia</button><img src="https://www.vitalitysocial.it/wp-content/plugins/wpforms-lite/assets/images/submit-spin.svg" class="wpforms-submit-spinner" style="display: none;" width="26" height="26" alt="Caricamento"></div></form></div>  <!-- .wpforms-container -->


<div> </div>
<div class="wp-block-file"><a id="wp-block-file--media-3728d32a-a69d-436d-9c8d-3fadb38b67b1" href="https://www.vitalitysocial.it/wp-content/uploads/2026/05/Bilancio-Sociale-2024.pdf">Bilancio Sociale 2024</a><a class="wp-block-file__button wp-element-button" href="https://www.vitalitysocial.it/wp-content/uploads/2026/05/Bilancio-Sociale-2024.pdf" download="" aria-describedby="wp-block-file--media-3728d32a-a69d-436d-9c8d-3fadb38b67b1">Download</a></div>
</div>
		</div>

<div class="wp-block-ub-content-toggle-accordion" style="border-color: #fff; border-top-left-radius: 8px; border-top-right-radius: 8px; border-bottom-left-radius: 8px; border-bottom-right-radius: 8px; " id="ub-content-toggle-panel-block-">
			<div class="wp-block-ub-content-toggle-accordion-title-wrap" style="background-color: #fff;" aria-controls="ub-content-toggle-panel-1-26a0f004-2b40-452e-874e-005ec917e124" tabindex="0">
			<h2 class="wp-block-ub-content-toggle-accordion-title ub-content-toggle-title-26a0f004-2b40-452e-874e-005ec917e124" style="color: #000000; ">Devolvi</h2>
			<div class="wp-block-ub-content-toggle-accordion-toggle-wrap right" style="color: #000000;"><span class="wp-block-ub-content-toggle-accordion-state-indicator wp-block-ub-chevron-down"></span></div>
		</div>
			<div role="region" aria-expanded="false" class="wp-block-ub-content-toggle-accordion-content-wrap ub-hide" id="ub-content-toggle-panel-1-26a0f004-2b40-452e-874e-005ec917e124">


<p class="wp-block-paragraph"> </p>
<p>Puoi devolvere i<strong>l 5 x 1000 </strong>dell’IRPEF indicando Vitality Impresa Sociale, <strong>codice fiscale 91062030407,</strong> nello spazio dedicato agli enti del terzo settore della tua dichiarazione dei redditi.</p>
</div>
		</div>

<div class="wp-block-ub-content-toggle-accordion" style="border-color: #fff; border-top-left-radius: 8px; border-top-right-radius: 8px; border-bottom-left-radius: 8px; border-bottom-right-radius: 8px; " id="ub-content-toggle-panel-block-">
			<div class="wp-block-ub-content-toggle-accordion-title-wrap" style="background-color: #fff;" aria-controls="ub-content-toggle-panel-2-26a0f004-2b40-452e-874e-005ec917e124" tabindex="0">
			<h2 class="wp-block-ub-content-toggle-accordion-title ub-content-toggle-title-26a0f004-2b40-452e-874e-005ec917e124" style="color: #000000; ">Partecipa</h2>
			<div class="wp-block-ub-content-toggle-accordion-toggle-wrap right" style="color: #000000;"><span class="wp-block-ub-content-toggle-accordion-state-indicator wp-block-ub-chevron-down"></span></div>
		</div>
			<div role="region" aria-expanded="false" class="wp-block-ub-content-toggle-accordion-content-wrap ub-hide" id="ub-content-toggle-panel-2-26a0f004-2b40-452e-874e-005ec917e124">


<p class="wp-block-paragraph">Se hai voglia di darci una mano nella gestione delle nostre <strong>imprese di comunità</strong>, nei nostri <strong>eventi sociali</strong> e nei nostri <strong>appuntamenti culturali,</strong> scrivici a sostieni@vitalitysocial.it.</p>
</div>
		</div>

<div class="wp-block-ub-content-toggle-accordion" style="border-color: #fff; border-top-left-radius: 8px; border-top-right-radius: 8px; border-bottom-left-radius: 8px; border-bottom-right-radius: 8px; " id="ub-content-toggle-panel-block-">
			<div class="wp-block-ub-content-toggle-accordion-title-wrap" style="background-color: #fff;" aria-controls="ub-content-toggle-panel-3-26a0f004-2b40-452e-874e-005ec917e124" tabindex="0">
			<h2 class="wp-block-ub-content-toggle-accordion-title ub-content-toggle-title-26a0f004-2b40-452e-874e-005ec917e124" style="color: #000000; ">Richiedi la tessera sostenitore</h2>
			<div class="wp-block-ub-content-toggle-accordion-toggle-wrap right" style="color: #000000;"><span class="wp-block-ub-content-toggle-accordion-state-indicator wp-block-ub-chevron-down"></span></div>
		</div>
			<div role="region" aria-expanded="false" class="wp-block-ub-content-toggle-accordion-content-wrap ub-hide" id="ub-content-toggle-panel-3-26a0f004-2b40-452e-874e-005ec917e124">


<figure id="block-3e9e80c8-e642-4ff0-9384-0f694a679005" class="wp-block-image"><img decoding="async" src="https://www.vitalitysocial.it/wp-content/uploads/2024/02/Tessera-sostenitore-fr-1024x672.png" alt="Questa immagine ha l'attributo alt vuoto; il nome del file è Tessera-sostenitore-fr-1024x672.png"></figure>



<p class="wp-block-paragraph" id="block-364e69f6-f2c8-4f3b-a987-bae3d2a2f412">Un modo <strong>triplamente soddisfacente</strong> di contribuire è richiedere la <strong>tessera sostenitore 2027</strong> i cui proventi quest'anno aiutano a coprire i costi dell'<strong>Ideificio</strong>, lo spazio di comunità che permette ai residenti fragili nella periferia di Milano di studiare, lavorare e socializzare in un ambiente sicuro e inclusivo.</p>



<p class="wp-block-paragraph" id="block-81c6b8f2-c595-4a8d-a39f-3784bdddb6bb">La tessera sostenitore ti da diritto a ricevere:</p>



<ul id="block-f69fe465-ad1c-40f0-8537-5559739d551c" class="wp-block-list">
<li>Sconto del 10% sui prodotti Ortoemporio</li>



<li>Sconto del 10% sui prodotti Ortocucina</li>



<li>Sconto del 10% sui catering Ortocucina</li>



<li>Tariffa agevolata sostenitore spazi Ideificio Ortobar (verifica <a href="https://docs.google.com/document/d/1R3JOvmn8050iD0E2159TwyRL0OzCVy0vKpL273HFkYI/edit?tab=t.0">tariffario aggiornato</a>)</li>



<li>Diritto di prelazione sui corsi di formazione gratuiti Vitality 2027</li>



<li>Sconto del 50% sui corsi di formazione a pagamento Vitality 2027</li>



<li>Diritto di prelazione sull'acquisto di prodotti e servizi del catalogo Incentive</li>



<li>Sconto del 50% per sull'acquisto di prodotti e servizi del catalogo Incentive</li>



<li>Diritto di prelazione VitaliTrip i viaggi annuali di Edutainemt</li>
</ul>



<p class="wp-block-paragraph" id="block-2cb68ead-4417-46c3-bfd5-677a50f378c7">Per ricevere la Tessera Sostenitore versa la <strong>quota annuale di 100 euro</strong> mediante una delle modalità indicate nella sezione <strong>Dona</strong> scrivendo nella causale - Tessera Sostenitore 2027 - e inserisci i tuoi dati sotto:</p>


<div class="wpforms-container wpforms-container-full wpforms-block wpforms-block-54299155-2f33-4e1b-9c09-8866f421cd64 wpforms-render-modern" id="wpforms-3773"><form id="wpforms-form-3773" class="wpforms-validate wpforms-form wpforms-ajax-form" data-formid="3773" method="post" enctype="multipart/form-data" action="/collabora/sostegno" data-token="8368dddeaca50a0e15807fa8682e869a" data-token-time="1791497849"><noscript class="wpforms-error-noscript">Abilita JavaScript nel browser per completare questo modulo.</noscript><div id="wpforms-error-noscript" style="display: none;">Abilita JavaScript nel browser per completare questo modulo.</div><div class="wpforms-field-container"><div id="wpforms-3773-field_3-container" class="wpforms-field wpforms-field-name" data-field-id="3"><fieldset><legend class="wpforms-field-label">Nome <span class="wpforms-required-label" aria-hidden="true">*</span></legend><div class="wpforms-field-row wpforms-field-medium"><div class="wpforms-field-row-block wpforms-first wpforms-one-half"><input type="text" id="wpforms-3773-field_3" class="wpforms-field-name-first wpforms-field-required" name="wpforms[fields][3][first]" aria-errormessage="wpforms-3773-field_3-error" required><label for="wpforms-3773-field_3" class="wpforms-field-sublabel after">Nome</label></div><div class="wpforms-field-row-block wpforms-one-half"><input type="text" id="wpforms-3773-field_3-last" class="wpforms-field-name-last wpforms-field-required" name="wpforms[fields][3][last]" aria-errormessage="wpforms-3773-field_3-last-error" required><label for="wpforms-3773-field_3-last" class="wpforms-field-sublabel after">Cognome</label></div></div></fieldset></div><div id="wpforms-3773-field_1-container" class="wpforms-field wpforms-field-text" data-field-id="1"><label class="wpforms-field-label" for="wpforms-3773-field_1">Indirizzo / Cap / Città <span class="wpforms-required-label" aria-hidden="true">*</span></label><input type="text" id="wpforms-3773-field_1" class="wpforms-field-medium wpforms-field-required" name="wpforms[fields][1]" aria-errormessage="wpforms-3773-field_1-error" required></div><div id="wpforms-3773-field_5-container" class="wpforms-field wpforms-field-email" data-field-id="5"><label class="wpforms-field-label" for="wpforms-3773-field_5">Email <span class="wpforms-required-label" aria-hidden="true">*</span></label><input type="email" id="wpforms-3773-field_5" class="wpforms-field-medium wpforms-field-required" name="wpforms[fields][5]" spellcheck="false" aria-errormessage="wpforms-3773-field_5-error" required></div><div id="wpforms-3773-field_2-container" class="wpforms-field wpforms-field-text" data-field-id="2"><label class="wpforms-field-label" for="wpforms-3773-field_2">Codice fiscale <span class="wpforms-required-label" aria-hidden="true">*</span></label><input type="text" id="wpforms-3773-field_2" class="wpforms-field-medium wpforms-field-required" name="wpforms[fields][2]" aria-errormessage="wpforms-3773-field_2-error" required></div>		<div id="wpforms-3773-field_6-container" class="wpforms-field wpforms-field-text" data-field-type="text" data-field-id="6">
			<label class="wpforms-field-label" for="wpforms-3773-field_6">Nome / un</label>
			<input type="text" id="wpforms-3773-field_6" class="wpforms-field-medium" name="wpforms[fields][6]">
		</div>
		<div id="wpforms-3773-field_4-container" class="wpforms-field wpforms-field-textarea" data-field-id="4"><label class="wpforms-field-label" for="wpforms-3773-field_4">Lascia un messaggio</label><textarea id="wpforms-3773-field_4" class="wpforms-field-medium" name="wpforms[fields][4]" aria-errormessage="wpforms-3773-field_4-error"></textarea></div><script>
				( function() {
					const style = document.createElement( 'style' );
					style.appendChild( document.createTextNode( '#wpforms-3758-field_6-container,#wpforms-3773-field_6-container { position: absolute !important; overflow: hidden !important; display: inline !important; height: 1px !important; width: 1px !important; z-index: -1000 !important; padding: 0 !important; } #wpforms-3758-field_6-container,#wpforms-3773-field_6-container input { visibility: hidden; } #wpforms-conversational-form-page #wpforms-3758-field_6-container,#wpforms-3773-field_6-container label { counter-increment: none; }' ) );
					document.head.appendChild( style );
					document.currentScript?.remove();
				} )();
			</script></div><!-- .wpforms-field-container --><div class="wpforms-submit-container"><input type="hidden" name="wpforms[id]" value="3773"><input type="hidden" name="wpforms[time_token]" value="1791497849.2574d71a525df1567afea91997a62c57c96f66035dcc712c0c76162fe7784c55"><input type="hidden" name="page_title" value="Collabora"><input type="hidden" name="page_url" value="https://www.vitalitysocial.it/collabora/sostegno"><input type="hidden" name="url_referer" value=""><input type="hidden" name="page_id" value="2510"><input type="hidden" name="wpforms[post_id]" value="2510"><button type="submit" name="wpforms[submit]" id="wpforms-submit-3773" class="wpforms-submit" data-alt-text="Invio in corso..." data-submit-text="Invia" aria-live="assertive" value="wpforms-submit">Invia</button><img src="https://www.vitalitysocial.it/wp-content/plugins/wpforms-lite/assets/images/submit-spin.svg" class="wpforms-submit-spinner" style="display: none;" width="26" height="26" alt="Caricamento"></div></form></div>  <!-- .wpforms-container --></div>
		</div></div>


<p class="wp-block-paragraph">&nbsp;</p>
</div>
</div>
<!-- /vcwb/dynamicElementComment:c65cd6f4 --></div>
</div>
</div>
<!-- /vcwb/dynamicElementComment:3d2d2f24 --></div>
</div>
</div>
<!-- /vcwb/dynamicElementComment:e12310fc -->