Die Erklärvideos werden beim Klicken auf den untenstehenden Button von externen Quellen unserer Partner bereitgestellt.
Bitte beachten Sie die Datenschutzerklärung.
<!--001b000000N6SggOTA-2023174334-->
	<style>
	td.videotitel, a#dsh {cursor: pointer;}
	</style>
	<style type="text/css">.datenschutz {
display:block !important;
}

td.videotitel {
padding:3px 0px 0px 5px !important;
}

td, tr, table {
border:0px !important;
background-color:transparent !important;
margin-bottom:0px !important;
padding:0px !important;
}</style><div class="videotipps">
	<style>
	.empfehlungshinweis {
	margin-top:20px;
	margin-bottom: 20px;
	}
	</style>
	<h3 class="ues_akt_vt">Der aktuelle Video-Tipp</h3><div class="aktuelles_video"><div class="videoblock"><div class="titelzeile" id="titelzeile75_1"><a class="anker" id="video75_1"></a>
					<h5 class="videotitel" id="videotitel75_1">Wege aus dem ID-Dschungel</h5></div>
			<div class="videozeile" id="videozeile75_1"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=Taxplain_ID-Dschungel_Movie190325&poster=https://www.deubner-online.de/taxplain/videopages/images/id_dschungel.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser75_1">Ein Unternehmer in Deutschland kann sich schon mal inmitten vieler unterschiedlicher Identifikationsnummern verlieren. Unser Video führt Sie sicher durch den ID-Dschungel! In nur drei Minuten wissen Sie, wo die vier wichtigsten IDs zu finden sind und wofür sie benötigt werden. (03/25)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Wege%20aus%20dem%20ID-Dschungel&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Wege%20aus%20dem%20ID-Dschungel'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Wege%20aus%20dem%20ID-Dschungel&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Wege%20aus%20dem%20ID-Dschungel»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><hr class="line_alle_videos"><br><h3 class="ues_alle_vt">Alle Video-Tipps</h3><h4 class="rubrik">F&uuml;r alle Steuerzahler</h4><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L68">Gesellschaftsregister für GbR: Bedeutung und Anmeldeverfahren</a></td></tr></table></div><div class="videoblock_rubrik" id="68" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile68_0"><a class="anker" id="video68_0"></a>
					<h5 class="videotitel" id="videotitel68_0">Gesellschaftsregister für GbR: Bedeutung und Anmeldeverfahren</h5></div>
			<div class="videozeile" id="videozeile68_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=gesreg_231201&poster=https://www.deubner-online.de/taxplain/videopages/images/egbr_1.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser68_0">Auch ohne gesetzliche Pflicht müssen sich viele GbRs in das neue Register eintragen lassen. Denn ohne Eintragung sind einige Geschäfte nicht mehr möglich. Wann eine GbR entsteht, ob Sie jetzt eine Eintragung veranlassen sollten und welche Konsequenzen eine Eintragung hat, erfahren Sie in diesem Video. (12/23)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Gesellschaftsregister%20für%20GbR:%20Bedeutung%20und%20Anmeldeverfahren&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Gesellschaftsregister%20für%20GbR:%20Bedeutung%20und%20Anmeldeverfahren'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_68_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_68_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Gesellschaftsregister%20für%20GbR:%20Bedeutung%20und%20Anmeldeverfahren&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_68_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_68_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_68_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Gesellschaftsregister%20für%20GbR:%20Bedeutung%20und%20Anmeldeverfahren»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_68_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_68_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L63">Arbeitszimmer: Welche Kosten Sie jetzt absetzen können</a></td></tr></table></div><div class="videoblock_rubrik" id="63" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile63_0"><a class="anker" id="video63_0"></a>
					<h5 class="videotitel" id="videotitel63_0">Arbeitszimmer: Welche Kosten Sie jetzt absetzen können</h5></div>
			<div class="videozeile" id="videozeile63_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=arbeitszimmer2023_130923&poster=https://www.deubner-online.de/taxplain/videopages/images/arbeitszimmer23_2.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser63_0">Wenn Sie zu Hause arbeiten, können Sie pauschal 6 € pro Tag und max. 1.260€ pro Jahr für anfallende Kosten steuerlich geltend machen. Haben Sie ein häusliches Arbeitszimmer, können Sie alle darauf entfallenden Kosten ansetzen. Aber Sie müssen verschiedene Voraussetzungen beachten. Die Abzugsmöglichkeiten und die Anforderungen dafür erklärt dieses Video. (9/23)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Arbeitszimmer:%20Welche%20Kosten%20Sie%20jetzt%20absetzen%20können&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Arbeitszimmer:%20Welche%20Kosten%20Sie%20jetzt%20absetzen%20können'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_63_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_63_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Arbeitszimmer:%20Welche%20Kosten%20Sie%20jetzt%20absetzen%20können&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_63_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_63_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_63_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Arbeitszimmer:%20Welche%20Kosten%20Sie%20jetzt%20absetzen%20können»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_63_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_63_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L65">Wie Kryptowährungen besteuert werden</a></td></tr></table></div><div class="videoblock_rubrik" id="65" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile65_0"><a class="anker" id="video65_0"></a>
					<h5 class="videotitel" id="videotitel65_0">Wie Kryptowährungen besteuert werden</h5></div>
			<div class="videozeile" id="videozeile65_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=Krypto_230420&poster=https://www.deubner-online.de/taxplain/videopages/images/kryptowaehrungen.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser65_0">Kryptowährungen werden immer häufiger als Spekulationsobjekt genutzt. Ob und wann dabei Steuern anfallen ist aber wenig bekannt. Dieses Video gibt einen Überblick über Transaktionen von Kryptowährungen und deren steuerliche Folgen. (5/23)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Wie%20Kryptowährungen%20besteuert%20werden&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Wie%20Kryptowährungen%20besteuert%20werden'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_65_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_65_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Wie%20Kryptowährungen%20besteuert%20werden&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_65_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_65_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_65_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Wie%20Kryptowährungen%20besteuert%20werden»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_65_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_65_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L54">Abschreiben von Computern und Software - Beachten Sie die neuen Steuerregeln des Finanzamtes</a></td></tr></table></div><div class="videoblock_rubrik" id="54" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile54_0"><a class="anker" id="video54_0"></a>
					<h5 class="videotitel" id="videotitel54_0">Abschreiben von Computern und Software - Beachten Sie die neuen Steuerregeln des Finanzamtes</h5></div>
			<div class="videozeile" id="videozeile54_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=afacomputer21062023&poster=https://www.deubner-online.de/taxplain/videopages/images/edvafa2021.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser54_0">Kosten für Computer und Software können ab 2021 in vielen Fällen sofort als Werbungskosten oder Betriebsausgaben abgezogen werden. Wann Sie den Sofortabzug nutzen können und wann Kosten weiterhin über mehrere Jahre abgeschrieben werden müssen, zeigt dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Abschreiben%20von%20Computern%20und%20Software%20-%20Beachten%20Sie%20die%20neuen%20Steuerregeln%20des%20Finanzamtes&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Abschreiben%20von%20Computern%20und%20Software%20-%20Beachten%20Sie%20die%20neuen%20Steuerregeln%20des%20Finanzamtes'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_54_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_54_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Abschreiben%20von%20Computern%20und%20Software%20-%20Beachten%20Sie%20die%20neuen%20Steuerregeln%20des%20Finanzamtes&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_54_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_54_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_54_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Abschreiben%20von%20Computern%20und%20Software%20-%20Beachten%20Sie%20die%20neuen%20Steuerregeln%20des%20Finanzamtes»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_54_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_54_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L7">Reisekosten: Diese Ausgaben können Sie absetzen</a></td></tr></table></div><div class="videoblock_rubrik" id="7" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile7_0"><a class="anker" id="video7_0"></a>
					<h5 class="videotitel" id="videotitel7_0">Reisekosten: Diese Ausgaben können Sie absetzen</h5></div>
			<div class="videozeile" id="videozeile7_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=reisekosten_240402&poster=https://www.deubner-online.de/taxplain/videopages/images/reisekosten.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser7_0">Wann werden die tatsächlichen Kosten angesetzt, wann Pauschalen? Und wie hoch sind die Pauschalen? Bei Reisekostenabrechnungen herrscht oft Unsicherheit. Diese Vorschriften müssen Sie aktuell beachten (4/24).
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Reisekosten:%20Diese%20Ausgaben%20können%20Sie%20absetzen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Reisekosten:%20Diese%20Ausgaben%20können%20Sie%20absetzen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_7_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_7_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Reisekosten:%20Diese%20Ausgaben%20können%20Sie%20absetzen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_7_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_7_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_7_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Reisekosten:%20Diese%20Ausgaben%20können%20Sie%20absetzen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_7_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_7_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L3">Dienstwagen: So wird die private Mitbenutzung versteuert</a></td></tr></table></div><div class="videoblock_rubrik" id="3" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile3_0"><a class="anker" id="video3_0"></a>
					<h5 class="videotitel" id="videotitel3_0">Dienstwagen: So wird die private Mitbenutzung versteuert</h5></div>
			<div class="videozeile" id="videozeile3_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=dienstwagen260518&poster=https://www.deubner-online.de/taxplain/videopages/images/Dienstwagen_20170113.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser3_0">Einen Dienstwagen nutzen Sie in der Regel nicht nur beruflich, sondern auch für private Fahrten. Dafür verlangt das Finanzamt Steuern. Die werden pauschal ermittelt, mit der sog. 1-%-Methode. Sie können aber auch ein Fahrtenbuch führen. Das Video zeigt, wie die beiden Methoden funktionieren.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Dienstwagen:%20So%20wird%20die%20private%20Mitbenutzung%20versteuert&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Dienstwagen:%20So%20wird%20die%20private%20Mitbenutzung%20versteuert'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_3_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_3_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Dienstwagen:%20So%20wird%20die%20private%20Mitbenutzung%20versteuert&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_3_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_3_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_3_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Dienstwagen:%20So%20wird%20die%20private%20Mitbenutzung%20versteuert»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_3_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_3_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L28">Was das Finanzamt über Sie weiß</a></td></tr></table></div><div class="videoblock_rubrik" id="28" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile28_0"><a class="anker" id="video28_0"></a>
					<h5 class="videotitel" id="videotitel28_0">Was das Finanzamt über Sie weiß</h5></div>
			<div class="videozeile" id="videozeile28_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=finanzamtinfos_270617&poster=https://www.deubner-online.de/taxplain/videopages/images/Finanzamtwissen_190617_low.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser28_0">Banken, Versicherungen, Arbeitgeber... Das Finanzamt wird von vielen Institutionen mit Daten über Sie gefüttert - ohne dass Sie etwas davon mitbekommen. Dieses Video zeigt, woher die Daten kommen und wie unsere Kanzlei Sie vor den Folgen fehlerhafter Daten schützt.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Was%20das%20Finanzamt%20über%20Sie%20weiß&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Was%20das%20Finanzamt%20über%20Sie%20weiß'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_28_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_28_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Was%20das%20Finanzamt%20über%20Sie%20weiß&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_28_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_28_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_28_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Was%20das%20Finanzamt%20über%20Sie%20weiß»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_28_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_28_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L11">Außergewöhnliche Belastungen: An diesen Kosten beteiligt sich der Fiskus</a></td></tr></table></div><div class="videoblock_rubrik" id="11" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile11_0"><a class="anker" id="video11_0"></a>
					<h5 class="videotitel" id="videotitel11_0">Außergewöhnliche Belastungen: An diesen Kosten beteiligt sich der Fiskus</h5></div>
			<div class="videozeile" id="videozeile11_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=aussergewbel020517&poster=https://www.deubner-online.de/taxplain/videopages/images/AussergewBel170503.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser11_0">Unvorhergesehene Ereignisse, wie Krankheiten oder Schäden am Eigenheim durch Naturkatastrophen, können zum finanziellen Desaster werden.  Sogenannte Außergewöhnliche Belastungen können Sie aber von der Steuer absetzen. Was Außergewöhnliche Belastungen sind und welche Kosten anerkannt werden, erläutert dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Außergewöhnliche%20Belastungen:%20An%20diesen%20Kosten%20beteiligt%20sich%20der%20Fiskus&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Außergewöhnliche%20Belastungen:%20An%20diesen%20Kosten%20beteiligt%20sich%20der%20Fiskus'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_11_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_11_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Außergewöhnliche%20Belastungen:%20An%20diesen%20Kosten%20beteiligt%20sich%20der%20Fiskus&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_11_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_11_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_11_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Außergewöhnliche%20Belastungen:%20An%20diesen%20Kosten%20beteiligt%20sich%20der%20Fiskus»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_11_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_11_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L6">Fahrtenbuch: So zeichnen Sie Dienstwagenfahrten finanzamtssicher auf</a></td></tr></table></div><div class="videoblock_rubrik" id="6" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile6_0"><a class="anker" id="video6_0"></a>
					<h5 class="videotitel" id="videotitel6_0">Fahrtenbuch: So zeichnen Sie Dienstwagenfahrten finanzamtssicher auf</h5></div>
			<div class="videozeile" id="videozeile6_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=fahrtenbuch_27082013&poster=https://www.deubner-online.de/taxplain/videopages/images/Fahrtenbuch_20170113.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser6_0">Mehrere hundert Euro Steuern können Dienstwagenfahrer mit einem Fahrtenbuch sparen. Allerdings werden Fahrtenbücher vom Finanzamt streng geprüft. Hier erfahren Sie, was Sie tun müssen, damit Ihr Fahrtenbuch anerkannt wird.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Fahrtenbuch:%20So%20zeichnen%20Sie%20Dienstwagenfahrten%20finanzamtssicher%20auf&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Fahrtenbuch:%20So%20zeichnen%20Sie%20Dienstwagenfahrten%20finanzamtssicher%20auf'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_6_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_6_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Fahrtenbuch:%20So%20zeichnen%20Sie%20Dienstwagenfahrten%20finanzamtssicher%20auf&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_6_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_6_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_6_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Fahrtenbuch:%20So%20zeichnen%20Sie%20Dienstwagenfahrten%20finanzamtssicher%20auf»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_6_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_6_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L9">Haushaltsnahe Dienstleistungen und Handwerkerkosten: So kassieren Sie einen Steuerbonus</a></td></tr></table></div><div class="videoblock_rubrik" id="9" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile9_0"><a class="anker" id="video9_0"></a>
					<h5 class="videotitel" id="videotitel9_0">Haushaltsnahe Dienstleistungen und Handwerkerkosten: So kassieren Sie einen Steuerbonus</h5></div>
			<div class="videozeile" id="videozeile9_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=haushaltsndienstleistg_080414&poster=https://www.deubner-online.de/taxplain/videopages/images/haushaltsndienstleistg_080414.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser9_0">Im Haushalt gibt es immer etwas zu tun: Sauber machen, Kinder betreuen, Reparaturen ... Wer ist da nicht froh, durch helfende Hände unterstützt zu werden? Der Fiskus fördert Beschäftigungen im Haushalt soger mit Bonuszahlungen. Für welche Tätigkeiten Sie den Bonus bekommen und welche Formalien Sie dafür einhalten müssen, erfahren Sie in diesem Video. 
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Haushaltsnahe%20Dienstleistungen%20und%20Handwerkerkosten:%20So%20kassieren%20Sie%20einen%20Steuerbonus&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Haushaltsnahe%20Dienstleistungen%20und%20Handwerkerkosten:%20So%20kassieren%20Sie%20einen%20Steuerbonus'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_9_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_9_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Haushaltsnahe%20Dienstleistungen%20und%20Handwerkerkosten:%20So%20kassieren%20Sie%20einen%20Steuerbonus&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_9_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_9_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_9_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Haushaltsnahe%20Dienstleistungen%20und%20Handwerkerkosten:%20So%20kassieren%20Sie%20einen%20Steuerbonus»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_9_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_9_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L22">Renten und Steuerpflicht: Was Sie unbedingt wissen sollten</a></td></tr></table></div><div class="videoblock_rubrik" id="22" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile22_0"><a class="anker" id="video22_0"></a>
					<h5 class="videotitel" id="videotitel22_0">Renten und Steuerpflicht: Was Sie unbedingt wissen sollten</h5></div>
			<div class="videozeile" id="videozeile22_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=rentner_040716&poster=https://www.deubner-online.de/taxplain/videopages/images/rente_steuern_160629.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser22_0">Immer mehr Rentner müssen eine Steuererklärung abgeben und viele wissen nichts davon. Das kann zu Ärger mit dem Finanzamt führen. Informieren Sie sich in diesem Video, unter welchen Umständen Sie bzw. Ihre Angehörigen im Ruhestand Steuern zahlen müssen und wie Sie sich richtig verhalten.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Renten%20und%20Steuerpflicht:%20Was%20Sie%20unbedingt%20wissen%20sollten&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Renten%20und%20Steuerpflicht:%20Was%20Sie%20unbedingt%20wissen%20sollten'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_22_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_22_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Renten%20und%20Steuerpflicht:%20Was%20Sie%20unbedingt%20wissen%20sollten&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_22_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_22_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_22_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Renten%20und%20Steuerpflicht:%20Was%20Sie%20unbedingt%20wissen%20sollten»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_22_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_22_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><br/><br/><h4 class="rubrik">F&uuml;r Gr&uuml;nder und Unternehmen</h4><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L75">Wege aus dem ID-Dschungel</a></td></tr></table></div><div class="videoblock_rubrik" id="75" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile75_0"><a class="anker" id="video75_0"></a>
					<h5 class="videotitel" id="videotitel75_0">Wege aus dem ID-Dschungel</h5></div>
			<div class="videozeile" id="videozeile75_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=Taxplain_ID-Dschungel_Movie190325&poster=https://www.deubner-online.de/taxplain/videopages/images/id_dschungel.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser75_0">Ein Unternehmer in Deutschland kann sich schon mal inmitten vieler unterschiedlicher Identifikationsnummern verlieren. Unser Video führt Sie sicher durch den ID-Dschungel! In nur drei Minuten wissen Sie, wo die vier wichtigsten IDs zu finden sind und wofür sie benötigt werden. (03/25)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Wege%20aus%20dem%20ID-Dschungel&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Wege%20aus%20dem%20ID-Dschungel'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Wege%20aus%20dem%20ID-Dschungel&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Wege%20aus%20dem%20ID-Dschungel»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_75_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L44">Kleinunternehmer: Wann Sie von der Umsatzsteuer befreit sind</a></td></tr></table></div><div class="videoblock_rubrik" id="44" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile44_0"><a class="anker" id="video44_0"></a>
					<h5 class="videotitel" id="videotitel44_0">Kleinunternehmer: Wann Sie von der Umsatzsteuer befreit sind</h5></div>
			<div class="videozeile" id="videozeile44_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kleinunternehmer_grundwissen_240917&poster=https://www.deubner-online.de/taxplain/videopages/images/kleinunternehmer_200302.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser44_0">Wenn Sie gerade ein Unternehmen gegründet haben oder im Vorjahr weniger als 25.000 Euro Umsatz hatten, können Sie sich von der Umsatzsteuerpflicht befreien lassen. Unter welchen Voraussetzungen das geht und wann das wirklich von Vorteil ist, erfahren Sie in diesem Video.(09/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Kleinunternehmer:%20Wann%20Sie%20von%20der%20Umsatzsteuer%20befreit%20sind&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Kleinunternehmer:%20Wann%20Sie%20von%20der%20Umsatzsteuer%20befreit%20sind'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_44_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_44_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Kleinunternehmer:%20Wann%20Sie%20von%20der%20Umsatzsteuer%20befreit%20sind&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_44_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_44_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_44_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Kleinunternehmer:%20Wann%20Sie%20von%20der%20Umsatzsteuer%20befreit%20sind»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_44_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_44_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L27">Rechnungen: Diese Angaben sind gesetzlich vorgeschrieben</a></td></tr></table></div><div class="videoblock_rubrik" id="27" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile27_0"><a class="anker" id="video27_0"></a>
					<h5 class="videotitel" id="videotitel27_0">Rechnungen: Diese Angaben sind gesetzlich vorgeschrieben</h5></div>
			<div class="videozeile" id="videozeile27_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=rechnungen_241213&poster=https://www.deubner-online.de/taxplain/videopages/images/rechnungen_241213.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser27_0">Selbstständige und Unternehmen bekommen gezahlte Umsatzsteuer vom Finanzamt zurück. Aber nur, wenn ordnungsgemäße Rechnungen vorliegen. Das Video zeigt, wie man das prüft. Dabei werden auch die Vereinfachungen für sogenannte Kleinbetragsrechnungen erläutert und auf die E-Rechnungspflicht eingegangen. (12/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Rechnungen:%20Diese%20Angaben%20sind%20gesetzlich%20vorgeschrieben&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Rechnungen:%20Diese%20Angaben%20sind%20gesetzlich%20vorgeschrieben'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_27_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_27_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Rechnungen:%20Diese%20Angaben%20sind%20gesetzlich%20vorgeschrieben&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_27_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_27_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_27_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Rechnungen:%20Diese%20Angaben%20sind%20gesetzlich%20vorgeschrieben»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_27_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_27_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L5">Geschenke an Mitarbeiter und Geschäftspartner: Achten Sie auf diese Steuerfallen</a></td></tr></table></div><div class="videoblock_rubrik" id="5" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile5_0"><a class="anker" id="video5_0"></a>
					<h5 class="videotitel" id="videotitel5_0">Geschenke an Mitarbeiter und Geschäftspartner: Achten Sie auf diese Steuerfallen</h5></div>
			<div class="videozeile" id="videozeile5_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=geschenke_241211&poster=https://www.deubner-online.de/taxplain/videopages/images/geschenke_100517.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser5_0">Frust statt Freude: Geschenke können zum Bumerang werden, wenn Sie die steuerlichen Besonderheiten nicht beachten. Erfahren Sie hier, wie Sie Geschenke an Geschäftspartner sicher als Betriebsausgaben geltend machen und wie Geschenke an Mitarbeiter lohnsteuerfrei bleiben. (12/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Geschenke%20an%20Mitarbeiter%20und%20Geschäftspartner:%20Achten%20Sie%20auf%20diese%20Steuerfallen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Geschenke%20an%20Mitarbeiter%20und%20Geschäftspartner:%20Achten%20Sie%20auf%20diese%20Steuerfallen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_5_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_5_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Geschenke%20an%20Mitarbeiter%20und%20Geschäftspartner:%20Achten%20Sie%20auf%20diese%20Steuerfallen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_5_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_5_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_5_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Geschenke%20an%20Mitarbeiter%20und%20Geschäftspartner:%20Achten%20Sie%20auf%20diese%20Steuerfallen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_5_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_5_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L60">Mindestlohn: Diese Punkte sollten Sie nach der Anhebung prüfen</a></td></tr></table></div><div class="videoblock_rubrik" id="60" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile60_0"><a class="anker" id="video60_0"></a>
					<h5 class="videotitel" id="videotitel60_0">Mindestlohn: Diese Punkte sollten Sie nach der Anhebung prüfen</h5></div>
			<div class="videozeile" id="videozeile60_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=mindestlohn_241203&poster=https://www.deubner-online.de/taxplain/videopages/images/mindestlohn25.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser60_0">Ab 2025 beträgt der Mindestlohn 12,82 €. Wird der Mindestlohn nicht eingehalten, muss der Arbeitgeber Sozialbeiträge nachzahlen. Das sollten Sie bei der Anhebung der Lohngrenze im Blick haben. Außerdem gibt es Fallen bei Aufzeichnungspflichten und Mitarbeitern von Subunternehmern. Im Video erfahren Sie mehr dazu. (12/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Mindestlohn:%20Diese%20Punkte%20sollten%20Sie%20nach%20der%20Anhebung%20prüfen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Mindestlohn:%20Diese%20Punkte%20sollten%20Sie%20nach%20der%20Anhebung%20prüfen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_60_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_60_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Mindestlohn:%20Diese%20Punkte%20sollten%20Sie%20nach%20der%20Anhebung%20prüfen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_60_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_60_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_60_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Mindestlohn:%20Diese%20Punkte%20sollten%20Sie%20nach%20der%20Anhebung%20prüfen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_60_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_60_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L69">Minijobs - das sind die aktuellen Regeln</a></td></tr></table></div><div class="videoblock_rubrik" id="69" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile69_0"><a class="anker" id="video69_0"></a>
					<h5 class="videotitel" id="videotitel69_0">Minijobs - das sind die aktuellen Regeln</h5></div>
			<div class="videozeile" id="videozeile69_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=minijobs_241203&poster=https://www.deubner-online.de/taxplain/videopages/images/minijobs25.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser69_0">Damit Sie die Vergünstigungen für Minijobber nutzen können, darf der Verdienst die aktuelle Obergrenze nicht überschreiten. Die wird automatisch mit dem Mindestlohn angehoben. Erfahren Sie in diesem Video, welche Verdienstgrenze ab 2025 gilt und welche Regeln außerdem zu beachten sind. (12/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Minijobs%20-%20das%20sind%20die%20aktuellen%20Regeln&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Minijobs%20-%20das%20sind%20die%20aktuellen%20Regeln'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_69_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_69_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Minijobs%20-%20das%20sind%20die%20aktuellen%20Regeln&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_69_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_69_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_69_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Minijobs%20-%20das%20sind%20die%20aktuellen%20Regeln»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_69_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_69_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L73">Änderungen für Kleinunternehmer: Umsatzgrenzen, E-Rechnungspflicht und EU-Umsätze</a></td></tr></table></div><div class="videoblock_rubrik" id="73" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile73_0"><a class="anker" id="video73_0"></a>
					<h5 class="videotitel" id="videotitel73_0">Änderungen für Kleinunternehmer: Umsatzgrenzen, E-Rechnungspflicht und EU-Umsätze</h5></div>
			<div class="videozeile" id="videozeile73_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kleinunternehmer_aenderungen_241209&poster=https://www.deubner-online.de/taxplain/videopages/images/kleinunternehmer_aenderungen25.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser73_0">Der Kleinunternehmerstatus ist an bestimmte Voraussetzungen gebunden, allem Voran an Umsatzgrenzen. Wie sich diese ändern, inwiefern Kleinunternehmer von der E-Rechnungspflicht betroffen sind und wie man den Kleinunternehmerstatus behalten und dabei EU-weite Umsätze tätigen kann, erfahren Sie in diesem Video. (12/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Änderungen%20für%20Kleinunternehmer:%20Umsatzgrenzen,%20E-Rechnungspflicht%20und%20EU-Umsätze&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Änderungen%20für%20Kleinunternehmer:%20Umsatzgrenzen,%20E-Rechnungspflicht%20und%20EU-Umsätze'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_73_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_73_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Änderungen%20für%20Kleinunternehmer:%20Umsatzgrenzen,%20E-Rechnungspflicht%20und%20EU-Umsätze&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_73_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_73_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_73_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Änderungen%20für%20Kleinunternehmer:%20Umsatzgrenzen,%20E-Rechnungspflicht%20und%20EU-Umsätze»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_73_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_73_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L72">Kasse richtig führen: Die Mitteilungs- und Aufzeichnungspflichten.</a></td></tr></table></div><div class="videoblock_rubrik" id="72" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile72_0"><a class="anker" id="video72_0"></a>
					<h5 class="videotitel" id="videotitel72_0">Kasse richtig führen: Die Mitteilungs- und Aufzeichnungspflichten.</h5></div>
			<div class="videozeile" id="videozeile72_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kassenfuehrung_240902&poster=https://www.deubner-online.de/taxplain/videopages/images/kassenfuehrung2024-09-02.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser72_0">Am 1. Januar 2025 tritt die Meldepflicht für elektronische Kassensysteme in Kraft. Welche Pflichten Mandanten jetzt schon haben, und welche ab 2025 neu hinzukommen, erläutert dieses Video kompakt in vier Minuten. (9/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Kasse%20richtig%20führen:%20Die%20Mitteilungs-%20und%20Aufzeichnungspflichten.&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Kasse%20richtig%20führen:%20Die%20Mitteilungs-%20und%20Aufzeichnungspflichten.'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_72_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_72_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Kasse%20richtig%20führen:%20Die%20Mitteilungs-%20und%20Aufzeichnungspflichten.&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_72_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_72_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_72_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Kasse%20richtig%20führen:%20Die%20Mitteilungs-%20und%20Aufzeichnungspflichten.»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_72_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_72_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L71">Die neue E-Rechnung – Antworten auf die 5 wichtigsten Fragen</a></td></tr></table></div><div class="videoblock_rubrik" id="71" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile71_0"><a class="anker" id="video71_0"></a>
					<h5 class="videotitel" id="videotitel71_0">Die neue E-Rechnung – Antworten auf die 5 wichtigsten Fragen</h5></div>
			<div class="videozeile" id="videozeile71_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=erechnung_240614&poster=https://www.deubner-online.de/taxplain/videopages/images/erechnung.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser71_0">2025 werden E-Rechnungen für Unternehmen Pflicht. Welche Übergangsfristen es gibt, welche Dateiformate zulässig sind und weitere wichtige Fragen zur Einführung erläutert dieses Video kompakt in drei Minuten (6/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Die%20neue%20E-Rechnung%20–%20Antworten%20auf%20die%205%20wichtigsten%20Fragen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Die%20neue%20E-Rechnung%20–%20Antworten%20auf%20die%205%20wichtigsten%20Fragen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_71_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_71_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Die%20neue%20E-Rechnung%20–%20Antworten%20auf%20die%205%20wichtigsten%20Fragen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_71_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_71_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_71_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Die%20neue%20E-Rechnung%20–%20Antworten%20auf%20die%205%20wichtigsten%20Fragen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_71_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_71_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L70">Sofortmeldungen an die Sozialversicherung: Das unterschätzte Bußgeldrisiko</a></td></tr></table></div><div class="videoblock_rubrik" id="70" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile70_0"><a class="anker" id="video70_0"></a>
					<h5 class="videotitel" id="videotitel70_0">Sofortmeldungen an die Sozialversicherung: Das unterschätzte Bußgeldrisiko</h5></div>
			<div class="videozeile" id="videozeile70_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=sofortmeldung_240307&poster=https://www.deubner-online.de/taxplain/videopages/images/sofortmeldungpic.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser70_0">In einigen Branchen müssen neue Beschäftigungen schon vor Arbeitsbeginn gemeldet werden. Bei Verstößen drohen Bußgelder. Welche Branchen das betrifft und wie und wann eine Meldung abzugeben ist, erfahren Sie in diesem Video. (3/24)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Sofortmeldungen%20an%20die%20Sozialversicherung:%20Das%20unterschätzte%20Bußgeldrisiko&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Sofortmeldungen%20an%20die%20Sozialversicherung:%20Das%20unterschätzte%20Bußgeldrisiko'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_70_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_70_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Sofortmeldungen%20an%20die%20Sozialversicherung:%20Das%20unterschätzte%20Bußgeldrisiko&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_70_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_70_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_70_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Sofortmeldungen%20an%20die%20Sozialversicherung:%20Das%20unterschätzte%20Bußgeldrisiko»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_70_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_70_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L62">Inflationsausgleichsprämie: Das gilt für Jobwechsler, Sachlohn, Mehrfachzahlungen und andere Sonderfälle</a></td></tr></table></div><div class="videoblock_rubrik" id="62" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile62_0"><a class="anker" id="video62_0"></a>
					<h5 class="videotitel" id="videotitel62_0">Inflationsausgleichsprämie: Das gilt für Jobwechsler, Sachlohn, Mehrfachzahlungen und andere Sonderfälle</h5></div>
			<div class="videozeile" id="videozeile62_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=inflationsausgleich_221118&poster=https://www.deubner-online.de/taxplain/videopages/images/inflationsausgleichspr.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser62_0">Wem können Arbeitgeber die Prämie von bis zu 3.000 € steuer- und sozialabgabenfrei zahlen? Und welche Gestaltungen sind dabei möglich? Dieses Video gibt Ihnen einen schnellen Überblick. (11/22)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Inflationsausgleichsprämie:%20Das%20gilt%20für%20Jobwechsler,%20Sachlohn,%20Mehrfachzahlungen%20und%20andere%20Sonderfälle&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Inflationsausgleichsprämie:%20Das%20gilt%20für%20Jobwechsler,%20Sachlohn,%20Mehrfachzahlungen%20und%20andere%20Sonderfälle'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_62_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_62_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Inflationsausgleichsprämie:%20Das%20gilt%20für%20Jobwechsler,%20Sachlohn,%20Mehrfachzahlungen%20und%20andere%20Sonderfälle&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_62_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_62_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_62_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Inflationsausgleichsprämie:%20Das%20gilt%20für%20Jobwechsler,%20Sachlohn,%20Mehrfachzahlungen%20und%20andere%20Sonderfälle»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_62_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_62_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L58">Transparenzregister - Was Sie als Geschäftsführer oder Vorstand jetzt melden müssen</a></td></tr></table></div><div class="videoblock_rubrik" id="58" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile58_0"><a class="anker" id="video58_0"></a>
					<h5 class="videotitel" id="videotitel58_0">Transparenzregister - Was Sie als Geschäftsführer oder Vorstand jetzt melden müssen</h5></div>
			<div class="videozeile" id="videozeile58_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=transparenzregister231129&poster=https://www.deubner-online.de/taxplain/videopages/images/Transparenzregister.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser58_0">Geschäftsführer müssen die sog. wirtschaftlich Berechtigten dem Transparenzregister mitteilen. Melden Sie zu spät oder fehlerhaft, drohen Bußgelder! Das Video bietet einen praktischen Überblick darüber, wer was melden muss (11/23).
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Transparenzregister%20-%20Was%20Sie%20als%20Geschäftsführer%20oder%20Vorstand%20jetzt%20melden%20müssen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Transparenzregister%20-%20Was%20Sie%20als%20Geschäftsführer%20oder%20Vorstand%20jetzt%20melden%20müssen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_58_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_58_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Transparenzregister%20-%20Was%20Sie%20als%20Geschäftsführer%20oder%20Vorstand%20jetzt%20melden%20müssen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_58_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_58_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_58_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Transparenzregister%20-%20Was%20Sie%20als%20Geschäftsführer%20oder%20Vorstand%20jetzt%20melden%20müssen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_58_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_58_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L53">Online- und Versandhandel - So funktioniert das neue Umsatzsteuerverfahren in der EU</a></td></tr></table></div><div class="videoblock_rubrik" id="53" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile53_0"><a class="anker" id="video53_0"></a>
					<h5 class="videotitel" id="videotitel53_0">Online- und Versandhandel - So funktioniert das neue Umsatzsteuerverfahren in der EU</h5></div>
			<div class="videozeile" id="videozeile53_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=fernverkauf210621&poster=https://www.deubner-online.de/taxplain/videopages/images/fernverkaufsregelung210621.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser53_0">Kleine Versandhändler sind im grenzüberschreitenden Handel jetzt viel öfter zur Besteuerung im Bestimmungsland verpflichtet. Schon bei mehr als 10.000 € Jahresumsatz mit Versänden in die EU. Das Video erklärt die Neuregelung und das zugehörige neue One-Stop-Shop Verfahren für die Abwicklung.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Online-%20und%20Versandhandel%20-%20So%20funktioniert%20das%20neue%20Umsatzsteuerverfahren%20in%20der%20EU&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Online-%20und%20Versandhandel%20-%20So%20funktioniert%20das%20neue%20Umsatzsteuerverfahren%20in%20der%20EU'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_53_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_53_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Online-%20und%20Versandhandel%20-%20So%20funktioniert%20das%20neue%20Umsatzsteuerverfahren%20in%20der%20EU&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_53_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_53_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_53_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Online-%20und%20Versandhandel%20-%20So%20funktioniert%20das%20neue%20Umsatzsteuerverfahren%20in%20der%20EU»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_53_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_53_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L20">Investitionsabzugsbetrag: Ausgaben absetzen, bevor Sie sie getätigt haben</a></td></tr></table></div><div class="videoblock_rubrik" id="20" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile20_0"><a class="anker" id="video20_0"></a>
					<h5 class="videotitel" id="videotitel20_0">Investitionsabzugsbetrag: Ausgaben absetzen, bevor Sie sie getätigt haben</h5></div>
			<div class="videozeile" id="videozeile20_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=iab_210201&poster=https://www.deubner-online.de/taxplain/videopages/images/iab_210201.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser20_0">Kosten für die Anschaffung beweglicher Wirtschaftsgüter können Sie bis zur Hälfte bereits 3 Jahre vor der Anschaffung geltend machen und so schon jetzt Ihre Steuerlast senken. Möglich macht das ein Investitionsabzugsbetrag. Wie Sie ihn nutzen, erfahren Sie in diesem Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Investitionsabzugsbetrag:%20Ausgaben%20absetzen,%20bevor%20Sie%20sie%20getätigt%20haben&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Investitionsabzugsbetrag:%20Ausgaben%20absetzen,%20bevor%20Sie%20sie%20getätigt%20haben'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_20_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_20_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Investitionsabzugsbetrag:%20Ausgaben%20absetzen,%20bevor%20Sie%20sie%20getätigt%20haben&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_20_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_20_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_20_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Investitionsabzugsbetrag:%20Ausgaben%20absetzen,%20bevor%20Sie%20sie%20getätigt%20haben»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_20_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_20_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L49">Digitale Rechnungen: So werden sie wie Papierrechnungen anerkannt</a></td></tr></table></div><div class="videoblock_rubrik" id="49" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile49_0"><a class="anker" id="video49_0"></a>
					<h5 class="videotitel" id="videotitel49_0">Digitale Rechnungen: So werden sie wie Papierrechnungen anerkannt</h5></div>
			<div class="videozeile" id="videozeile49_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=digitalerechnungen201112&poster=https://www.deubner-online.de/taxplain/videopages/images/digitaleRG.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser49_0">Schon länger sind digitale Rechnungen Papierrechnungen gleichgestellt. Das Umsatzsteuergesetz knüpft deren Anerkennung allerdings an einige Anforderungen, die in diesem Video erläutert werden.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Digitale%20Rechnungen:%20So%20werden%20sie%20wie%20Papierrechnungen%20anerkannt&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Digitale%20Rechnungen:%20So%20werden%20sie%20wie%20Papierrechnungen%20anerkannt'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_49_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_49_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Digitale%20Rechnungen:%20So%20werden%20sie%20wie%20Papierrechnungen%20anerkannt&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_49_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_49_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_49_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Digitale%20Rechnungen:%20So%20werden%20sie%20wie%20Papierrechnungen%20anerkannt»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_49_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_49_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L43">Die aktuellen technischen Anforderungen an elektronische Kassen</a></td></tr></table></div><div class="videoblock_rubrik" id="43" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile43_0"><a class="anker" id="video43_0"></a>
					<h5 class="videotitel" id="videotitel43_0">Die aktuellen technischen Anforderungen an elektronische Kassen</h5></div>
			<div class="videozeile" id="videozeile43_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kasse200917&poster=https://www.deubner-online.de/taxplain/videopages/images/Kassenfunktion_191009.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser43_0">Für elektronische Kassen gibt es seit 2020 neue Anforderungen. U.a. ist eine Technische Sicherheitseinrichtung Pflicht. Hat Ihre Kasse, die noch nicht, droht Ärger mit dem Finanzamt. Was Sie tun müssen, zeigt dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Die%20aktuellen%20technischen%20Anforderungen%20an%20elektronische%20Kassen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Die%20aktuellen%20technischen%20Anforderungen%20an%20elektronische%20Kassen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_43_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_43_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Die%20aktuellen%20technischen%20Anforderungen%20an%20elektronische%20Kassen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_43_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_43_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_43_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Die%20aktuellen%20technischen%20Anforderungen%20an%20elektronische%20Kassen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_43_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_43_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L40">E-Fahrzeuge für Mitarbeiter: Neue Steuervergünstigungen für Auto und Jobrad</a></td></tr></table></div><div class="videoblock_rubrik" id="40" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile40_0"><a class="anker" id="video40_0"></a>
					<h5 class="videotitel" id="videotitel40_0">E-Fahrzeuge für Mitarbeiter: Neue Steuervergünstigungen für Auto und Jobrad</h5></div>
			<div class="videozeile" id="videozeile40_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=efirmenfahrzeuge_200825&poster=https://www.deubner-online.de/taxplain/videopages/images/efirmenfahrzeuge190326.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser40_0">Die Überlassung von E-Fahrzeugen an Arbeitnehmer wird stärker gefördert: Für Elektro-Firmenwagen wird nur die halbe, für viele reine E-Fahrzeuge sogar nur ein Viertel der "Dienstwagensteuer"  fällig. Jobfahrräder können Mitarbeitern sogar lohnsteuerfrei überlassen werden. Das Video erklärt, wie Sie davon profitieren.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=E-Fahrzeuge%20für%20Mitarbeiter:%20Neue%20Steuervergünstigungen%20für%20Auto%20und%20Jobrad&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'E-Fahrzeuge%20für%20Mitarbeiter:%20Neue%20Steuervergünstigungen%20für%20Auto%20und%20Jobrad'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_40_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_40_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20E-Fahrzeuge%20für%20Mitarbeiter:%20Neue%20Steuervergünstigungen%20für%20Auto%20und%20Jobrad&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_40_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_40_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_40_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«E-Fahrzeuge%20für%20Mitarbeiter:%20Neue%20Steuervergünstigungen%20für%20Auto%20und%20Jobrad»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_40_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_40_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L46">Liquidität: Mit diesen Maßnahmen bleiben Sie auch bei Umsatzeinbrüchen zahlungsfähig</a></td></tr></table></div><div class="videoblock_rubrik" id="46" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile46_0"><a class="anker" id="video46_0"></a>
					<h5 class="videotitel" id="videotitel46_0">Liquidität: Mit diesen Maßnahmen bleiben Sie auch bei Umsatzeinbrüchen zahlungsfähig</h5></div>
			<div class="videozeile" id="videozeile46_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=liquiditaet290520&poster=https://www.deubner-online.de/taxplain/videopages/images/liquiditaet.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser46_0">Zahlungsunfähigkeit ist der häufigste Insolvenzgrund. Deshalb ist wichtig, Liquiditätsengpässe früh zu erkennen und Maßnahmen dagegen einzuleiten. Das Video zeigt, wie wir Ihnen dabei helfen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Liquidität:%20Mit%20diesen%20Maßnahmen%20bleiben%20Sie%20auch%20bei%20Umsatzeinbrüchen%20zahlungsfähig&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Liquidität:%20Mit%20diesen%20Maßnahmen%20bleiben%20Sie%20auch%20bei%20Umsatzeinbrüchen%20zahlungsfähig'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_46_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_46_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Liquidität:%20Mit%20diesen%20Maßnahmen%20bleiben%20Sie%20auch%20bei%20Umsatzeinbrüchen%20zahlungsfähig&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_46_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_46_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_46_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Liquidität:%20Mit%20diesen%20Maßnahmen%20bleiben%20Sie%20auch%20bei%20Umsatzeinbrüchen%20zahlungsfähig»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_46_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_46_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L45">Steuerstundung und -herabsetzung: Erleichterungen in der Krise nutzen</a></td></tr></table></div><div class="videoblock_rubrik" id="45" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile45_0"><a class="anker" id="video45_0"></a>
					<h5 class="videotitel" id="videotitel45_0">Steuerstundung und -herabsetzung: Erleichterungen in der Krise nutzen</h5></div>
			<div class="videozeile" id="videozeile45_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=steuertundung200327&poster=https://www.deubner-online.de/taxplain/videopages/images/steuerstundung200327.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser45_0">Wenn Sie aufgrund der Corona-Krise in Liquiditätsschwierigkeiten kommen, beantragen wir für Sie Steuerstundungen. Das Video zeigt, wie sie profitieren und welche Informationen wir dafür von Ihnen benötigen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Steuerstundung%20und%20-herabsetzung:%20Erleichterungen%20in%20der%20Krise%20nutzen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Steuerstundung%20und%20-herabsetzung:%20Erleichterungen%20in%20der%20Krise%20nutzen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_45_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_45_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Steuerstundung%20und%20-herabsetzung:%20Erleichterungen%20in%20der%20Krise%20nutzen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_45_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_45_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_45_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Steuerstundung%20und%20-herabsetzung:%20Erleichterungen%20in%20der%20Krise%20nutzen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_45_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_45_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L23">Kasse richtig führen: Die neuen Pflichten ab 2020</a></td></tr></table></div><div class="videoblock_rubrik" id="23" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile23_0"><a class="anker" id="video23_0"></a>
					<h5 class="videotitel" id="videotitel23_0">Kasse richtig führen: Die neuen Pflichten ab 2020</h5></div>
			<div class="videozeile" id="videozeile23_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kassenfuehrung_191213&poster=https://www.deubner-online.de/taxplain/videopages/images/kassenfuehrung2020_191216.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser23_0">Neben neuen technischen Vorschriften gibt es für Sie als Betreiber von Kassen auch neue bürokratische Aufgaben, wie Belegausgabepflicht, Kassen-Meldepflicht und neue Aufzeichnungspflichten. Das Video erklärt die neuen Pflichten.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Kasse%20richtig%20führen:%20Die%20neuen%20Pflichten%20ab%202020&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Kasse%20richtig%20führen:%20Die%20neuen%20Pflichten%20ab%202020'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_23_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_23_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Kasse%20richtig%20führen:%20Die%20neuen%20Pflichten%20ab%202020&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_23_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_23_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_23_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Kasse%20richtig%20führen:%20Die%20neuen%20Pflichten%20ab%202020»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_23_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_23_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L14">Verfahrensdokumentation für Kassen</a></td></tr></table></div><div class="videoblock_rubrik" id="14" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile14_0"><a class="anker" id="video14_0"></a>
					<h5 class="videotitel" id="videotitel14_0">Verfahrensdokumentation für Kassen</h5></div>
			<div class="videozeile" id="videozeile14_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=vdkasse151119&poster=https://www.deubner-online.de/taxplain/videopages/images/vdkasse191216.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser14_0">Eine Verfahrensdokumentation verlangen Prüfer bei Kassennachschauen künftig verstärkt. Wie Sie eine solche Dokumentation erstellen und was drinstehen muss, erklärt dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Verfahrensdokumentation%20für%20Kassen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Verfahrensdokumentation%20für%20Kassen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_14_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_14_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Verfahrensdokumentation%20für%20Kassen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_14_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_14_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_14_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Verfahrensdokumentation%20für%20Kassen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_14_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_14_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L42">Leasing oder Kauf: Die richtige Entscheidung ohne finanzielle Reue</a></td></tr></table></div><div class="videoblock_rubrik" id="42" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile42_0"><a class="anker" id="video42_0"></a>
					<h5 class="videotitel" id="videotitel42_0">Leasing oder Kauf: Die richtige Entscheidung ohne finanzielle Reue</h5></div>
			<div class="videozeile" id="videozeile42_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=leasingkorr_190813_2&poster=https://www.deubner-online.de/taxplain/videopages/images/leasing190808.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser42_0">Mit Leasing können Sie Ihr Budget schonen und Steuern sparen. Aber Leasingverträge können auch teure Fallen enthalten. Sehen Sie in diesem Video, was Sie vor der Entscheidung für Leasing bedenken sollten.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Leasing%20oder%20Kauf:%20Die%20richtige%20Entscheidung%20ohne%20finanzielle%20Reue&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Leasing%20oder%20Kauf:%20Die%20richtige%20Entscheidung%20ohne%20finanzielle%20Reue'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_42_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_42_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Leasing%20oder%20Kauf:%20Die%20richtige%20Entscheidung%20ohne%20finanzielle%20Reue&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_42_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_42_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_42_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Leasing%20oder%20Kauf:%20Die%20richtige%20Entscheidung%20ohne%20finanzielle%20Reue»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_42_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_42_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L41">Rechnungen digitalisieren: So ersetzt der Scan rechtssicher die Papierrechnung</a></td></tr></table></div><div class="videoblock_rubrik" id="41" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile41_0"><a class="anker" id="video41_0"></a>
					<h5 class="videotitel" id="videotitel41_0">Rechnungen digitalisieren: So ersetzt der Scan rechtssicher die Papierrechnung</h5></div>
			<div class="videozeile" id="videozeile41_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=ersetzendesscannen250619&poster=https://www.deubner-online.de/taxplain/videopages/images/ersetzendesscannen190618.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser41_0">Erhalten Sie Papierrechnungen, k&ouml;nnen Sie diese durch das sogenannte ersetzende Scannen in gleichwertige digitale Rechnungen umwandeln. Die lassen sich wesentlich einfacher bearbeiten, aufbewahren und durchsuchen. Das Video erkl&auml;rt, wie Sie das ersetzende Scannen rechtssicher nutzen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Rechnungen%20digitalisieren:%20So%20ersetzt%20der%20Scan%20rechtssicher%20die%20Papierrechnung&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Rechnungen%20digitalisieren:%20So%20ersetzt%20der%20Scan%20rechtssicher%20die%20Papierrechnung'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_41_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_41_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Rechnungen%20digitalisieren:%20So%20ersetzt%20der%20Scan%20rechtssicher%20die%20Papierrechnung&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_41_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_41_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_41_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Rechnungen%20digitalisieren:%20So%20ersetzt%20der%20Scan%20rechtssicher%20die%20Papierrechnung»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_41_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_41_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L39">Gutscheine: Wann und in welcher Höhe Umsatzsteuer anfällt</a></td></tr></table></div><div class="videoblock_rubrik" id="39" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile39_0"><a class="anker" id="video39_0"></a>
					<h5 class="videotitel" id="videotitel39_0">Gutscheine: Wann und in welcher Höhe Umsatzsteuer anfällt</h5></div>
			<div class="videozeile" id="videozeile39_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=gutschein220119&poster=https://www.deubner-online.de/taxplain/videopages/images/Gutschein190122a.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser39_0">Wann muss für Gutscheine beim Finanzamt Umsatzsteuer angemeldet und gezahlt werden – schon nach dem Verkauf oder erst nach der Einlösung? Entscheidend ist nach der Neuregelung ab Anfang 2019, ob es sich um einen Einzweck- oder Mehrzweck-Gutschein handelt. Wie sie die unterscheiden, um bei der Umsatzsteuer alles richtig zu machen, erfahren Sie in diesem Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Gutscheine:%20Wann%20und%20in%20welcher%20Höhe%20Umsatzsteuer%20anfällt&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Gutscheine:%20Wann%20und%20in%20welcher%20Höhe%20Umsatzsteuer%20anfällt'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_39_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_39_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Gutscheine:%20Wann%20und%20in%20welcher%20Höhe%20Umsatzsteuer%20anfällt&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_39_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_39_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_39_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Gutscheine:%20Wann%20und%20in%20welcher%20Höhe%20Umsatzsteuer%20anfällt»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_39_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_39_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L33">Datenschutzgrundverordnung: Der richtige Umgang mit personenbezogenen Daten</a></td></tr></table></div><div class="videoblock_rubrik" id="33" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile33_0"><a class="anker" id="video33_0"></a>
					<h5 class="videotitel" id="videotitel33_0">Datenschutzgrundverordnung: Der richtige Umgang mit personenbezogenen Daten</h5></div>
			<div class="videozeile" id="videozeile33_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=dsgvotax180312&poster=https://www.deubner-online.de/taxplain/videopages/images/DSGVOallg180312.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser33_0">In praktisch jedem Unternehmen fallen personenbezogene Daten zu Kunden und Mitarbeitern an. Die sind spätestens ab 25.5.2018 nach der EU-weit geltenden Datenschutzgrundverordnung (DSGVO) zu behandeln. Die DSGVO geht weit über das bisherige Datenschutzrecht hinaus. Bei Verstößen drohen Bußgelder bis 20 Mio. Euro. Das Video erklärt, wie Sie bei der Umsetzung der DSGVO richtig vorgehen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Datenschutzgrundverordnung:%20Der%20richtige%20Umgang%20mit%20personenbezogenen%20Daten&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Datenschutzgrundverordnung:%20Der%20richtige%20Umgang%20mit%20personenbezogenen%20Daten'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_33_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_33_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Datenschutzgrundverordnung:%20Der%20richtige%20Umgang%20mit%20personenbezogenen%20Daten&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_33_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_33_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_33_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Datenschutzgrundverordnung:%20Der%20richtige%20Umgang%20mit%20personenbezogenen%20Daten»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_33_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_33_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L32">Verfahrensdokumentation: So müssen Sie Ihre Buchführung für das Finanzamt beschreiben</a></td></tr></table></div><div class="videoblock_rubrik" id="32" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile32_0"><a class="anker" id="video32_0"></a>
					<h5 class="videotitel" id="videotitel32_0">Verfahrensdokumentation: So müssen Sie Ihre Buchführung für das Finanzamt beschreiben</h5></div>
			<div class="videozeile" id="videozeile32_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=verfdok_200218&poster=https://www.deubner-online.de/taxplain/videopages/images/VerfDok180221.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser32_0">Bei Betriebsprüfungen werden Sie künftig eine Verfahrensdokumentation für Ihre Buchführung vorlegen müssen. Die soll beschreiben, wie Belege von der Eingabe bis zur Speicherung verarbeitet werden. Welche Bestandteile eine Verfahrensdokumentation haben soll und wie Sie die Dokumentation erstellen, erfahren Sie in diesem Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Verfahrensdokumentation:%20So%20müssen%20Sie%20Ihre%20Buchführung%20für%20das%20Finanzamt%20beschreiben&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Verfahrensdokumentation:%20So%20müssen%20Sie%20Ihre%20Buchführung%20für%20das%20Finanzamt%20beschreiben'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_32_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_32_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Verfahrensdokumentation:%20So%20müssen%20Sie%20Ihre%20Buchführung%20für%20das%20Finanzamt%20beschreiben&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_32_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_32_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_32_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Verfahrensdokumentation:%20So%20müssen%20Sie%20Ihre%20Buchführung%20für%20das%20Finanzamt%20beschreiben»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_32_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_32_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L30">Die neue Kassen-Nachschau: Das sind Ihre Rechte und Pflichten</a></td></tr></table></div><div class="videoblock_rubrik" id="30" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile30_0"><a class="anker" id="video30_0"></a>
					<h5 class="videotitel" id="videotitel30_0">Die neue Kassen-Nachschau: Das sind Ihre Rechte und Pflichten</h5></div>
			<div class="videozeile" id="videozeile30_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kassennachschau201017&poster=https://www.deubner-online.de/taxplain/videopages/images/kassenpruefung.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser30_0">Ab 2018 darf das Finanzamt unangekündigt Ihre Barkasse prüfen. Vor allem die neuen Aufzeichnungspflichten werden dabei kontrolliert. Was darf der Prüfer und wo sind die Grenzen? Das erläutert Ihnen dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Die%20neue%20Kassen-Nachschau:%20Das%20sind%20Ihre%20Rechte%20und%20Pflichten&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Die%20neue%20Kassen-Nachschau:%20Das%20sind%20Ihre%20Rechte%20und%20Pflichten'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_30_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_30_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Die%20neue%20Kassen-Nachschau:%20Das%20sind%20Ihre%20Rechte%20und%20Pflichten&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_30_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_30_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_30_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Die%20neue%20Kassen-Nachschau:%20Das%20sind%20Ihre%20Rechte%20und%20Pflichten»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_30_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_30_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L29">Scheinselbstständigkeit: Die Kriterien und die finanziellen Konsequenzen</a></td></tr></table></div><div class="videoblock_rubrik" id="29" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile29_0"><a class="anker" id="video29_0"></a>
					<h5 class="videotitel" id="videotitel29_0">Scheinselbstständigkeit: Die Kriterien und die finanziellen Konsequenzen</h5></div>
			<div class="videozeile" id="videozeile29_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=scheinselbstst_270617&poster=https://www.deubner-online.de/taxplain/videopages/images/scheinselbststaendig_20170915.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser29_0">Selbstständige dürfen frei über ihre finanzielle Absicherung entscheiden. Arbeiten sie jedoch wie Arbeitnehmer, können sie sozialversicherungspflichtig sein. Auf diese Punkte müssen Auftraggeber und Auftragnehmer achten, um teure Nachzahlungen in die Sozialversicherung zu vermeiden.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Scheinselbstständigkeit:%20Die%20Kriterien%20und%20die%20finanziellen%20Konsequenzen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Scheinselbstständigkeit:%20Die%20Kriterien%20und%20die%20finanziellen%20Konsequenzen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_29_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_29_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Scheinselbstständigkeit:%20Die%20Kriterien%20und%20die%20finanziellen%20Konsequenzen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_29_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_29_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_29_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Scheinselbstständigkeit:%20Die%20Kriterien%20und%20die%20finanziellen%20Konsequenzen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_29_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_29_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L8">Bewirtungskosten: So erkennt das Finanzamt Geschäftsessen an</a></td></tr></table></div><div class="videoblock_rubrik" id="8" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile8_0"><a class="anker" id="video8_0"></a>
					<h5 class="videotitel" id="videotitel8_0">Bewirtungskosten: So erkennt das Finanzamt Geschäftsessen an</h5></div>
			<div class="videozeile" id="videozeile8_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=bewirtungskosten_090817&poster=https://www.deubner-online.de/taxplain/videopages/images/bewirtungskosten_10052017.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser8_0">Laden Sie Geschäftspartner oder Kunden zum Essen ein, können Sie dafür Betriebsausgaben und Vorsteuer geltend machen. Allerdings prüft das Finanzamt genau, ob das Essen tatsächlich rein beruflich war. Außerdem brauchen Sie einen ordnungsgemäßen Bewirtungsbeleg. Alle wichtigen Infos zu Bewirtungskosten erfahren Sie in diesem Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Bewirtungskosten:%20So%20erkennt%20das%20Finanzamt%20Geschäftsessen%20an&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Bewirtungskosten:%20So%20erkennt%20das%20Finanzamt%20Geschäftsessen%20an'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_8_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_8_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Bewirtungskosten:%20So%20erkennt%20das%20Finanzamt%20Geschäftsessen%20an&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_8_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_8_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_8_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Bewirtungskosten:%20So%20erkennt%20das%20Finanzamt%20Geschäftsessen%20an»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_8_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_8_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L15">Elektronische Buchführung: Diese Regeln müssen alle Selbstständigen beachten</a></td></tr></table></div><div class="videoblock_rubrik" id="15" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile15_0"><a class="anker" id="video15_0"></a>
					<h5 class="videotitel" id="videotitel15_0">Elektronische Buchführung: Diese Regeln müssen alle Selbstständigen beachten</h5></div>
			<div class="videozeile" id="videozeile15_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=gobd_191216&poster=https://www.deubner-online.de/taxplain/videopages/images/GoBD_100517.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser15_0">Eine "Buchführung" mit der u.a. Zahlungen, Materialverbrauch, Arbeitszeiten usw. dokumentiert werden, hat jedes Unternehmen. Da die Aufzeichnungen auch Grundlage für die Besteuerung sind, macht die Finanzverwaltung für elektronische Aufzeichnungen mit den GoBD Vorgaben. Was Sie bei Aufzeichnungen beachten müssen, erfahren Sie in diesem Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Elektronische%20Buchführung:%20Diese%20Regeln%20müssen%20alle%20Selbstständigen%20beachten&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Elektronische%20Buchführung:%20Diese%20Regeln%20müssen%20alle%20Selbstständigen%20beachten'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_15_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_15_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Elektronische%20Buchführung:%20Diese%20Regeln%20müssen%20alle%20Selbstständigen%20beachten&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_15_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_15_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_15_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Elektronische%20Buchführung:%20Diese%20Regeln%20müssen%20alle%20Selbstständigen%20beachten»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_15_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_15_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L1">Kassenbuch: Die 5 gefährlichsten Steuerfallen - und wie Sie sie vermeiden</a></td></tr></table></div><div class="videoblock_rubrik" id="1" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile1_0"><a class="anker" id="video1_0"></a>
					<h5 class="videotitel" id="videotitel1_0">Kassenbuch: Die 5 gefährlichsten Steuerfallen - und wie Sie sie vermeiden</h5></div>
			<div class="videozeile" id="videozeile1_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kassenbuch_010117&poster=https://www.deubner-online.de/taxplain/videopages/images/Kassenbuch_20170113.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser1_0">Die Fallen im Kassenbuch werden oft unterschätzt. Fehler können zur Folge haben, dass das Finanzamt die Bareinnahmen schätzt - natürlich mit großzügigem Aufschlag. So vermeiden Sie die 5 häufigsten Fehler.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Kassenbuch:%20Die%205%20gefährlichsten%20Steuerfallen%20-%20und%20wie%20Sie%20sie%20vermeiden&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Kassenbuch:%20Die%205%20gefährlichsten%20Steuerfallen%20-%20und%20wie%20Sie%20sie%20vermeiden'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_1_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_1_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Kassenbuch:%20Die%205%20gefährlichsten%20Steuerfallen%20-%20und%20wie%20Sie%20sie%20vermeiden&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_1_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_1_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_1_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Kassenbuch:%20Die%205%20gefährlichsten%20Steuerfallen%20-%20und%20wie%20Sie%20sie%20vermeiden»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_1_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_1_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L25">Erbschaftsteuer: Wann die Steuer greift und wie Sie Befreiungen nutzen</a></td></tr></table></div><div class="videoblock_rubrik" id="25" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile25_0"><a class="anker" id="video25_0"></a>
					<h5 class="videotitel" id="videotitel25_0">Erbschaftsteuer: Wann die Steuer greift und wie Sie Befreiungen nutzen</h5></div>
			<div class="videozeile" id="videozeile25_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=erbschaftsteuer_151116&poster=https://www.deubner-online.de/taxplain/videopages/images/erbschaftsteuerreform_20161116.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser25_0">Rückwirkend für Schenkungen und Erbschaften seit 1.7.2016 ist die Erbschaftsteuerreform in Kraft getreten. Vor allem Familienunternehmen können damit weitgehende Steuererleichterungen nutzen. Dafür gibt es einige neue Voraussetzungen. Informieren Sie sich mit diesem Video über die Steuererleichterungen und wie Sie davon profitieren.

			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Erbschaftsteuer:%20Wann%20die%20Steuer%20greift%20und%20wie%20Sie%20Befreiungen%20nutzen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Erbschaftsteuer:%20Wann%20die%20Steuer%20greift%20und%20wie%20Sie%20Befreiungen%20nutzen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_25_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_25_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Erbschaftsteuer:%20Wann%20die%20Steuer%20greift%20und%20wie%20Sie%20Befreiungen%20nutzen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_25_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_25_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_25_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Erbschaftsteuer:%20Wann%20die%20Steuer%20greift%20und%20wie%20Sie%20Befreiungen%20nutzen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_25_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_25_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L12">Umkehr der Steuerschuldnerschaft: Wann der Rechnungsempfänger die Umsatzsteuer zahlen muss</a></td></tr></table></div><div class="videoblock_rubrik" id="12" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile12_0"><a class="anker" id="video12_0"></a>
					<h5 class="videotitel" id="videotitel12_0">Umkehr der Steuerschuldnerschaft: Wann der Rechnungsempfänger die Umsatzsteuer zahlen muss</h5></div>
			<div class="videozeile" id="videozeile12_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=steuerschuldnerschaft_290914&poster=https://www.deubner-online.de/taxplain/videopages/images/Ustumkehr_20170113.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser12_0">Selbst wenn der Empfänger Ihrer Rechnung die Umsatzsteuer an das Finanzamt abführen muss, ist das für Sie keine Vereinfachung. Denn wenn Sie eine Rechnung fälschlicherweise ohne Umsatzsteuer ausstellen, drohen Ärger und Steuernachzahlungen. Dieses Video zeigt Ihnen anhand der aktuellsten Rechtslage ab 1.10.2014, wann Sie von der sogenannten Umkehr der Steuerschuldnerschaft betroffen sind und wie Sie richtig damit umgehen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Umkehr%20der%20Steuerschuldnerschaft:%20Wann%20der%20Rechnungsempfänger%20die%20Umsatzsteuer%20zahlen%20muss&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Umkehr%20der%20Steuerschuldnerschaft:%20Wann%20der%20Rechnungsempfänger%20die%20Umsatzsteuer%20zahlen%20muss'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_12_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_12_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Umkehr%20der%20Steuerschuldnerschaft:%20Wann%20der%20Rechnungsempfänger%20die%20Umsatzsteuer%20zahlen%20muss&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_12_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_12_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_12_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Umkehr%20der%20Steuerschuldnerschaft:%20Wann%20der%20Rechnungsempfänger%20die%20Umsatzsteuer%20zahlen%20muss»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_12_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_12_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><br/><br/><h4 class="rubrik">F&uuml;r Arbeitnehmer</h4><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L52">Steuerfalle Progressionsvorbehalt – Wann steuerfreie Einnahmen zu Steuernachzahlungen führen</a></td></tr></table></div><div class="videoblock_rubrik" id="52" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile52_0"><a class="anker" id="video52_0"></a>
					<h5 class="videotitel" id="videotitel52_0">Steuerfalle Progressionsvorbehalt – Wann steuerfreie Einnahmen zu Steuernachzahlungen führen</h5></div>
			<div class="videozeile" id="videozeile52_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=progression270521&poster=https://www.deubner-online.de/taxplain/videopages/images/progressionsvorbehalt.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser52_0">Kurzarbeitergeld, Elterngeld, Arbeitslosengeld und weitere Ersatzzahlungen sind zwar steuerfrei, können aber wegen des sogenannten Progressionsvorbehalts Ihre Steuerlast erhöhen und zu Steuernachzahlungen führen. Erfahren Sie in diesem Video, wann und wie sich der Progressionsvorbehalt auswirkt.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Steuerfalle%20Progressionsvorbehalt%20–%20Wann%20steuerfreie%20Einnahmen%20zu%20Steuernachzahlungen%20führen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Steuerfalle%20Progressionsvorbehalt%20–%20Wann%20steuerfreie%20Einnahmen%20zu%20Steuernachzahlungen%20führen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_52_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_52_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Steuerfalle%20Progressionsvorbehalt%20–%20Wann%20steuerfreie%20Einnahmen%20zu%20Steuernachzahlungen%20führen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_52_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_52_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_52_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Steuerfalle%20Progressionsvorbehalt%20–%20Wann%20steuerfreie%20Einnahmen%20zu%20Steuernachzahlungen%20führen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_52_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_52_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L18">Lohnsteuerermäßigung: So erhöhen Sie Ihren monatlichen Nettolohn</a></td></tr></table></div><div class="videoblock_rubrik" id="18" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile18_0"><a class="anker" id="video18_0"></a>
					<h5 class="videotitel" id="videotitel18_0">Lohnsteuerermäßigung: So erhöhen Sie Ihren monatlichen Nettolohn</h5></div>
			<div class="videozeile" id="videozeile18_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=lsterm_230101&poster=https://www.deubner-online.de/taxplain/videopages/images/lsterm.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser18_0">Mit einem Lohnsteuerermäßigungsantrag können Sie steuerrelevante Ausgaben direkt bei der Lohnabrechnung berücksichtigen lassen. So erhöhen Sie Ihren monatlichen Nettolohn. Das macht sich gerade in Zeiten hoher Inflation im Portemonnaie bemerkbar. In diesem Video erfahren Sie, wie Sie vorgehen. (1/23)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Lohnsteuerermäßigung:%20So%20erhöhen%20Sie%20Ihren%20monatlichen%20Nettolohn&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Lohnsteuerermäßigung:%20So%20erhöhen%20Sie%20Ihren%20monatlichen%20Nettolohn'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_18_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_18_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Lohnsteuerermäßigung:%20So%20erhöhen%20Sie%20Ihren%20monatlichen%20Nettolohn&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_18_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_18_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_18_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Lohnsteuerermäßigung:%20So%20erhöhen%20Sie%20Ihren%20monatlichen%20Nettolohn»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_18_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_18_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L31">Doppelte Haushaltsführung: So machen Sie Kosten für einen zweiten Wohnsitz steuerlich geltend</a></td></tr></table></div><div class="videoblock_rubrik" id="31" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile31_0"><a class="anker" id="video31_0"></a>
					<h5 class="videotitel" id="videotitel31_0">Doppelte Haushaltsführung: So machen Sie Kosten für einen zweiten Wohnsitz steuerlich geltend</h5></div>
			<div class="videozeile" id="videozeile31_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=doppeltehaushalt_080118&poster=https://www.deubner-online.de/taxplain/videopages/images/doppelhf20180109.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser31_0">Wenn Wohnort und Arbeitsplatz so weit auseinander liegen, dass tägliches Pendeln nicht möglich ist, wird häufig eine zweite Wohnung am Arbeitsplatz angemietet. Die Kosten können steuerlich geltend gemacht werden. Die Voraussetzungen dafür erläutert dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Doppelte%20Haushaltsführung:%20So%20machen%20Sie%20Kosten%20für%20einen%20zweiten%20Wohnsitz%20steuerlich%20geltend&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Doppelte%20Haushaltsführung:%20So%20machen%20Sie%20Kosten%20für%20einen%20zweiten%20Wohnsitz%20steuerlich%20geltend'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_31_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_31_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Doppelte%20Haushaltsführung:%20So%20machen%20Sie%20Kosten%20für%20einen%20zweiten%20Wohnsitz%20steuerlich%20geltend&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_31_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_31_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_31_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Doppelte%20Haushaltsführung:%20So%20machen%20Sie%20Kosten%20für%20einen%20zweiten%20Wohnsitz%20steuerlich%20geltend»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_31_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_31_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L24">Lohnsteuerklassen: Wie Sie durch die richtige Wahl mehr Nettolohn und Ersatzleistungen erhalten</a></td></tr></table></div><div class="videoblock_rubrik" id="24" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile24_0"><a class="anker" id="video24_0"></a>
					<h5 class="videotitel" id="videotitel24_0">Lohnsteuerklassen: Wie Sie durch die richtige Wahl mehr Nettolohn und Ersatzleistungen erhalten</h5></div>
			<div class="videozeile" id="videozeile24_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=steuerklassenwahl_250416&poster=https://www.deubner-online.de/taxplain/videopages/images/steuerklassen_29042016.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser24_0">Die Steuerklasse beeinflusst bei Arbeitnehmern den monatlichen Nettolohn. Das wirkt sich auch auf die Höhe von Eltern- oder Arbeitslosengeld aus. Viele Paare können ihre Steuerklassen wählen. Wie Sie das geschickt nutzen, um Nettolohn und Ersatzleistungen zu erhöhen, erklärt dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Lohnsteuerklassen:%20Wie%20Sie%20durch%20die%20richtige%20Wahl%20mehr%20Nettolohn%20und%20Ersatzleistungen%20erhalten&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Lohnsteuerklassen:%20Wie%20Sie%20durch%20die%20richtige%20Wahl%20mehr%20Nettolohn%20und%20Ersatzleistungen%20erhalten'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_24_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_24_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Lohnsteuerklassen:%20Wie%20Sie%20durch%20die%20richtige%20Wahl%20mehr%20Nettolohn%20und%20Ersatzleistungen%20erhalten&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_24_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_24_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_24_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Lohnsteuerklassen:%20Wie%20Sie%20durch%20die%20richtige%20Wahl%20mehr%20Nettolohn%20und%20Ersatzleistungen%20erhalten»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_24_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_24_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><br/><br/><h4 class="rubrik">F&uuml;r Immobilienbesitzer</h4><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L74">Grundsteuerbescheid: Wie Sie Fehler finden und was Sie jetzt dagegen tun können</a></td></tr></table></div><div class="videoblock_rubrik" id="74" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile74_0"><a class="anker" id="video74_0"></a>
					<h5 class="videotitel" id="videotitel74_0">Grundsteuerbescheid: Wie Sie Fehler finden und was Sie jetzt dagegen tun können</h5></div>
			<div class="videozeile" id="videozeile74_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=grundsteuerbescheid_250218&poster=https://www.deubner-online.de/taxplain/videopages/images/grundsteuerbescheid.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser74_0">Ein Grundsteuerbescheid ist in der Regel korrekt, auch wenn die Kosten ab 2025 deutlich gestiegen sind. In manchen Fällen kann er aber angefochten werden. Wie Sie mögliche Fehler entdecken und was Sie dagegen unternehmen können, erläutert dieses Video. (02/25)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Grundsteuerbescheid:%20Wie%20Sie%20Fehler%20finden%20und%20was%20Sie%20jetzt%20dagegen%20tun%20können&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Grundsteuerbescheid:%20Wie%20Sie%20Fehler%20finden%20und%20was%20Sie%20jetzt%20dagegen%20tun%20können'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_74_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_74_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Grundsteuerbescheid:%20Wie%20Sie%20Fehler%20finden%20und%20was%20Sie%20jetzt%20dagegen%20tun%20können&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_74_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_74_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_74_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Grundsteuerbescheid:%20Wie%20Sie%20Fehler%20finden%20und%20was%20Sie%20jetzt%20dagegen%20tun%20können»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_74_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_74_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L67">Die neuen Heizungsförderungen - So begrenzen Sie Ihre finanzielle Belastung</a></td></tr></table></div><div class="videoblock_rubrik" id="67" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile67_0"><a class="anker" id="video67_0"></a>
					<h5 class="videotitel" id="videotitel67_0">Die neuen Heizungsförderungen - So begrenzen Sie Ihre finanzielle Belastung</h5></div>
			<div class="videozeile" id="videozeile67_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=Heizungsfoerderung_231024&poster=https://www.deubner-online.de/taxplain/videopages/images/heizungsfoerderung.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser67_0">Auch wenn das neue Heizungsgesetz nun doch weniger Hausbesitzer zum sofortigen Austausch zwingt als befürchtet, steht bei vielen bald eine Modernisierung an. Welche Finanzierungshilfen gibt es dafür? Einen Überblick gibt Ihnen das Video. (10/23)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Die%20neuen%20Heizungsförderungen%20-%20So%20begrenzen%20Sie%20Ihre%20finanzielle%20Belastung&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Die%20neuen%20Heizungsförderungen%20-%20So%20begrenzen%20Sie%20Ihre%20finanzielle%20Belastung'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_67_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_67_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Die%20neuen%20Heizungsförderungen%20-%20So%20begrenzen%20Sie%20Ihre%20finanzielle%20Belastung&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_67_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_67_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_67_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Die%20neuen%20Heizungsförderungen%20-%20So%20begrenzen%20Sie%20Ihre%20finanzielle%20Belastung»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_67_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_67_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L66">Gebäudesanierung: So steuert das Finanzamt bis zu 40.000 € bei</a></td></tr></table></div><div class="videoblock_rubrik" id="66" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile66_0"><a class="anker" id="video66_0"></a>
					<h5 class="videotitel" id="videotitel66_0">Gebäudesanierung: So steuert das Finanzamt bis zu 40.000 € bei</h5></div>
			<div class="videozeile" id="videozeile66_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=35cEStG_GebSan_230524&poster=https://www.deubner-online.de/taxplain/videopages/images/35cEStG_GebSan.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser66_0">Der Staat fördert energetische Gebäudesanierungen mit einem Steuerbonus. Das Video zeigt die Voraussetzungen, um den Bonus zu bekommen. (6/23)
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Gebäudesanierung:%20So%20steuert%20das%20Finanzamt%20bis%20zu%2040.000%20€%20bei&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Gebäudesanierung:%20So%20steuert%20das%20Finanzamt%20bis%20zu%2040.000%20€%20bei'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_66_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_66_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Gebäudesanierung:%20So%20steuert%20das%20Finanzamt%20bis%20zu%2040.000%20€%20bei&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_66_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_66_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_66_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Gebäudesanierung:%20So%20steuert%20das%20Finanzamt%20bis%20zu%2040.000%20€%20bei»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_66_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_66_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L55">Photovoltaikanlagen - So nutzen Sie die aktuellen Steuererleichterungen</a></td></tr></table></div><div class="videoblock_rubrik" id="55" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile55_0"><a class="anker" id="video55_0"></a>
					<h5 class="videotitel" id="videotitel55_0">Photovoltaikanlagen - So nutzen Sie die aktuellen Steuererleichterungen</h5></div>
			<div class="videozeile" id="videozeile55_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=pv_221221&poster=https://www.deubner-online.de/taxplain/videopages/images/pvanlagen211007.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser55_0">Als Betreiber einer kleinen Photovoltaikanlage mit bis zu 30 Kilowatt Leistung können Sie neue steuerliche Vereinfachungen nutzen. Das Video zeigt, welche das sind und welche Fristen und sonstigen Voraussetzungen zu beachten sind (1/23).
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Photovoltaikanlagen%20-%20So%20nutzen%20Sie%20die%20aktuellen%20Steuererleichterungen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Photovoltaikanlagen%20-%20So%20nutzen%20Sie%20die%20aktuellen%20Steuererleichterungen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_55_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_55_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Photovoltaikanlagen%20-%20So%20nutzen%20Sie%20die%20aktuellen%20Steuererleichterungen&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_55_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_55_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_55_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Photovoltaikanlagen%20-%20So%20nutzen%20Sie%20die%20aktuellen%20Steuererleichterungen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_55_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_55_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L35">Verkauf von Immobilien & Co. - Wann Steuern anfallen und wie Sie sie vermeiden</a></td></tr></table></div><div class="videoblock_rubrik" id="35" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile35_0"><a class="anker" id="video35_0"></a>
					<h5 class="videotitel" id="videotitel35_0">Verkauf von Immobilien & Co. - Wann Steuern anfallen und wie Sie sie vermeiden</h5></div>
			<div class="videozeile" id="videozeile35_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=immobilienco110918&poster=https://www.deubner-online.de/taxplain/videopages/images/privVeraeusserung_180908.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser35_0">„Spekulationssteuer“ fällt nicht nur auf Aktiengewinne an. Auch beim Verkauf von Häusern, Wein und Autos etc. hält der Fiskus oft die Hand auf. Steuern vermeiden Sie bei privaten Veräußerungen, wenn Sie die Spekulations-Fristen abwarten. Die sind bei Sachwerten unterschiedlich. Das Video zeigt, welche Fristen zu beachten sind und welche weiteren Steuersparmöglichkeiten Sie insbesondere bei Immobilienverkäufen nutzen können.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Verkauf%20von%20Immobilien%20&%20Co.%20-%20Wann%20Steuern%20anfallen%20und%20wie%20Sie%20sie%20vermeiden&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Verkauf%20von%20Immobilien%20&%20Co.%20-%20Wann%20Steuern%20anfallen%20und%20wie%20Sie%20sie%20vermeiden'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_35_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_35_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Verkauf%20von%20Immobilien%20&%20Co.%20-%20Wann%20Steuern%20anfallen%20und%20wie%20Sie%20sie%20vermeiden&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_35_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_35_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_35_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Verkauf%20von%20Immobilien%20&%20Co.%20-%20Wann%20Steuern%20anfallen%20und%20wie%20Sie%20sie%20vermeiden»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_35_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_35_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><div class="videotitel-link"><table style="border-spacing: 0px; border-collapse: separate;"><tr class="videozeile"><td class="videosymbol" style="width:20px;vertical-align:top;"><img class="i_videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a id="L34">Vermietung an Angehörige: So erkennt das Finanzamt günstige Gestaltungen an</a></td></tr></table></div><div class="videoblock_rubrik" id="34" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile34_0"><a class="anker" id="video34_0"></a>
					<h5 class="videotitel" id="videotitel34_0">Vermietung an Angehörige: So erkennt das Finanzamt günstige Gestaltungen an</h5></div>
			<div class="videozeile" id="videozeile34_0"><div class="h_iframe"><iframe class="inlinevideo" scrolling="no" src="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=vermietang201211&poster=https://www.deubner-online.de/taxplain/videopages/images/vermAngeh180605.jpg&kdnr=001b000000N6Sgg&v_modus=0&service=taxplain" width="500" height="291" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe><img class="ratio" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/16x9.png" /></div></div><br/>	
			<div class="teaser" id="teaser34_0">Vermietung an Angehörige ist ein beliebtes Modell zur Steueroptimierung. Praktische Beispiele dafür zeigt dieses Video. Aber auch Hinweise, welche Anforderungen das Finanzamt stellt, damit Kosten für die Immobilie optimal geltend gemacht werden können. 
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Vermietung%20an%20Angehörige:%20So%20erkennt%20das%20Finanzamt%20günstige%20Gestaltungen%20an&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Vermietung%20an%20Angehörige:%20So%20erkennt%20das%20Finanzamt%20günstige%20Gestaltungen%20an'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_34_t_nn.html" title="Mail versenden"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="Mail versenden" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_mail2.svg"></a><a class="smb" href="https://www.facebook.com/sharer.php?u=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_34_t_nn.html" title="FB" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="FB (teilen)" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_fb.svg"/></a><a class="smb" href="https://twitter.com/share?text=Ich%20empfehle%20folgendes%20Video:%20Vermietung%20an%20Angehörige:%20So%20erkennt%20das%20Finanzamt%20günstige%20Gestaltungen%20an&url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_34_t_nn.html" title="TW" target="_blank"><img class="sm_icon" style="margin-right: 3px; height:24px; width:24px;" alt="TW" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_twitter.svg"/></a><a class="smb" href="https://www.xing.com/social_plugins/share/new?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_34_t_nn.html" title="XI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="XI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_xing.svg"/></a><a class="smb" href="https://www.linkedin.com/sharing/share-offsite/?url=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_34_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Vermietung%20an%20Angehörige:%20So%20erkennt%20das%20Finanzamt%20günstige%20Gestaltungen%20an»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_34_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/001b000000N6Sgg_34_t_nn.html" title="LI" target="_blank"><img class="sm_icon" style="margin-right:3px; height:24px; width:24px;" alt="LI" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/sm_linkedin.svg"/></a></div></div>
			</div><br/><br/>
		<div class="datenschutz" style="display:block">
			<hr class="datenschutz">
			<a rel="nofollow" title="https://www.deubner-verlag.de/datenschutzerklaerung-homepageservice" id="dsh">Datenschutzhinweis</a>
		</div><!--VNR=0--></div><script src="https://deubner-online.de/einbau/taxplain/videopages/js/taxplain.js"></script>