Service-Videos
Wir helfen Ihnen, die umfangreichen Pflichten des deutschen Steuerrechts zu erfüllen. Einige Fragen tauchen immer wieder auf. Dazu finden Sie hier eine Auswahl von Videos mit praktischen Erklärungen.
Wenn Sie darüber hinaus Fragen haben, nehmen Sie bitte mit uns Kontakt auf.
Aufgrund ihrer Datenschutz- und Cookie-Einstellungen wird der Inhalt gerade blockiert. Klicken Sie auf den unteren Button, um die Servicevideos oder den Steuerrechner zu laden.
 <script>function FensterOeffnen (Adresse, breite, hoehe) {MeinFenster = window.open(Adresse, "Zweitfenster", "width="+breite+",height="+hoehe+", left=200,top=200,scrollbars=1,style='background-color:#000'");MeinFenster.focus();}</script><script>function toggleDiv(element){ if(document.getElementById(element).style.display == 'none') {document.getElementById(element).style.display = 'block';} else document.getElementById(element).style.display = 'none';
}</script>
<!--517737940OTA-201856928--><div class="videotipps"><script src="https://www.mandantenvideo.de/commons/js/lytebox/lytebox.js"></script><link rel="stylesheet" href="https://www.mandantenvideo.de/commons/js/lytebox/lytebox.css" type="text/css" media="screen" /><h3 class="ues_akt_vt">Der aktuelle Video-Tipp</h3><div class="aktuelles_video"><div class="videoblock"><div class="titelzeile" id="titelzeile58_1"><a class="anker" id="video58_1"></a>
					<h5 class="videotitel" id="videotitel58_1">Transparenzregister - Was Sie als Geschäftsführer oder Vorstand jetzt melden müssen</h5></div>
			<div class="videozeile" id="videozeile58_1"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=transparenzregister220509&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Transparenzregister - Was Sie als Geschäftsführer oder Vorstand jetzt melden müssen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Transparenzregister.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser58_1">Sie 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 wann melden muss.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; 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/517737940_58_t_nn.html" title="Mail versenden"><img 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/517737940_58_t_nn.html" title="FB" target="_blank"><img 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/517737940_58_t_nn.html" title="TW" target="_blank"><img 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/517737940_58_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_58_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_58_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('54');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=afacomputer21062023&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Abschreiben von Computern und Software - Beachten Sie die neuen Steuerregeln des Finanzamtes" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/edvafa2021.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_54_t_nn.html" title="Mail versenden"><img 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/517737940_54_t_nn.html" title="FB" target="_blank"><img 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/517737940_54_t_nn.html" title="TW" target="_blank"><img 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/517737940_54_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_54_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_54_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('51');">Zu Hause arbeiten wegen Corona - Was Sie über die Homeoffice-Pauschale hinaus absetzen können</a></td></tr></table></div><div class="videoblock_rubrik" id="51" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile51_0"><a class="anker" id="video51_0"></a>
					<h5 class="videotitel" id="videotitel51_0">Zu Hause arbeiten wegen Corona - Was Sie über die Homeoffice-Pauschale hinaus absetzen können</h5></div>
			<div class="videozeile" id="videozeile51_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=heimarbeit_210315&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Zu Hause arbeiten wegen Corona - Was Sie über die Homeoffice-Pauschale hinaus absetzen können" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/homeoffice.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser51_0">Weniger Kosten für den Arbeitsweg, dafür mehr Kosten zu Hause. Aber welche Kosten können Sie in der Steuererklärung geltend machen, wenn Sie vermehrt zu Hause arbeiten? Dieses Video zeigt es Ihnen. Und vor allem auch, welche Unterlagen und Nachweise dafür nötig sind.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Zu%20Hause%20arbeiten%20wegen%20Corona%20-%20Was%20Sie%20über%20die%20Homeoffice-Pauschale%20hinaus%20absetzen%20können&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Zu%20Hause%20arbeiten%20wegen%20Corona%20-%20Was%20Sie%20über%20die%20Homeoffice-Pauschale%20hinaus%20absetzen%20können'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_51_t_nn.html" title="Mail versenden"><img 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/517737940_51_t_nn.html" title="FB" target="_blank"><img 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:%20Zu%20Hause%20arbeiten%20wegen%20Corona%20-%20Was%20Sie%20über%20die%20Homeoffice-Pauschale%20hinaus%20absetzen%20können&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_51_t_nn.html" title="TW" target="_blank"><img 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/517737940_51_t_nn.html" title="XI" target="_blank"><img 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/517737940_51_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Zu%20Hause%20arbeiten%20wegen%20Corona%20-%20Was%20Sie%20über%20die%20Homeoffice-Pauschale%20hinaus%20absetzen%20können»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_51_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_51_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('7');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=reisekosten_191217&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Reisekosten: Diese Ausgaben können Sie absetzen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Reisekosten_20170113.jpg" style="width:300px"></a></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.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; 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/517737940_7_t_nn.html" title="Mail versenden"><img 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/517737940_7_t_nn.html" title="FB" target="_blank"><img 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/517737940_7_t_nn.html" title="TW" target="_blank"><img 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/517737940_7_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_7_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_7_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('3');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=dienstwagen260518&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Dienstwagen: So wird die private Mitbenutzung versteuert" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Dienstwagen_20170113.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_3_t_nn.html" title="Mail versenden"><img 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/517737940_3_t_nn.html" title="FB" target="_blank"><img 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/517737940_3_t_nn.html" title="TW" target="_blank"><img 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/517737940_3_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_3_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_3_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('28');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=finanzamtinfos_270617&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Was das Finanzamt über Sie weiß" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Finanzamtwissen_190617_low.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_28_t_nn.html" title="Mail versenden"><img 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/517737940_28_t_nn.html" title="FB" target="_blank"><img 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/517737940_28_t_nn.html" title="TW" target="_blank"><img 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/517737940_28_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_28_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_28_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('11');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=aussergewbel020517&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Außergewöhnliche Belastungen: An diesen Kosten beteiligt sich der Fiskus" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/AussergewBel170503.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_11_t_nn.html" title="Mail versenden"><img 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/517737940_11_t_nn.html" title="FB" target="_blank"><img 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/517737940_11_t_nn.html" title="TW" target="_blank"><img 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/517737940_11_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_11_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_11_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('10');">Arbeitszimmer: Wie Sie Kosten für das heimische Büro richtig absetzen</a></td></tr></table></div><div class="videoblock_rubrik" id="10" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile10_0"><a class="anker" id="video10_0"></a>
					<h5 class="videotitel" id="videotitel10_0">Arbeitszimmer: Wie Sie Kosten für das heimische Büro richtig absetzen</h5></div>
			<div class="videozeile" id="videozeile10_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=arbeitszimmer_030414&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Arbeitszimmer: Wie Sie Kosten für das heimische Büro richtig absetzen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/arbeitszimmer_20170113.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser10_0">Wer die entscheidenden Tätigkeiten für seinen Beruf dort erledigt oder keinen anderen Arbeitsplatz zur Verfügung hat, kann die Kosten für sein Heimbüro steuerlich geltend machen. Das gilt für Selbstständige und für Angestellte. Aber das Finanzamt kontrolliert penibel, ob die Voraussetzungen erfüllt sind. Erfahren Sie hier, welche Voraussetzungen zu beachten sind und welche Kosten Sie genau absetzen können.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Arbeitszimmer:%20Wie%20Sie%20Kosten%20für%20das%20heimische%20Büro%20richtig%20absetzen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Arbeitszimmer:%20Wie%20Sie%20Kosten%20für%20das%20heimische%20Büro%20richtig%20absetzen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_10_t_nn.html" title="Mail versenden"><img 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/517737940_10_t_nn.html" title="FB" target="_blank"><img 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:%20Wie%20Sie%20Kosten%20für%20das%20heimische%20Büro%20richtig%20absetzen&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_10_t_nn.html" title="TW" target="_blank"><img 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/517737940_10_t_nn.html" title="XI" target="_blank"><img 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/517737940_10_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Arbeitszimmer:%20Wie%20Sie%20Kosten%20für%20das%20heimische%20Büro%20richtig%20absetzen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_10_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_10_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('6');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=fahrtenbuch_27082013&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Fahrtenbuch: So zeichnen Sie Dienstwagenfahrten finanzamtssicher auf" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Fahrtenbuch_20170113.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_6_t_nn.html" title="Mail versenden"><img 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/517737940_6_t_nn.html" title="FB" target="_blank"><img 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/517737940_6_t_nn.html" title="TW" target="_blank"><img 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/517737940_6_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_6_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_6_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('9');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=haushaltsndienstleistg_080414&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Haushaltsnahe Dienstleistungen und Handwerkerkosten: So kassieren Sie einen Steuerbonus" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/haushalthilfen_20170113.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_9_t_nn.html" title="Mail versenden"><img 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/517737940_9_t_nn.html" title="FB" target="_blank"><img 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/517737940_9_t_nn.html" title="TW" target="_blank"><img 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/517737940_9_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_9_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_9_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('22');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=rentner_040716&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Renten und Steuerpflicht: Was Sie unbedingt wissen sollten" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/rente_steuern_160629.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_22_t_nn.html" title="Mail versenden"><img 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/517737940_22_t_nn.html" title="FB" target="_blank"><img 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/517737940_22_t_nn.html" title="TW" target="_blank"><img 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/517737940_22_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_22_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_22_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('58');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=transparenzregister220509&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Transparenzregister - Was Sie als Geschäftsführer oder Vorstand jetzt melden müssen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Transparenzregister.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser58_0">Sie 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 wann melden muss.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; 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/517737940_58_t_nn.html" title="Mail versenden"><img 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/517737940_58_t_nn.html" title="FB" target="_blank"><img 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/517737940_58_t_nn.html" title="TW" target="_blank"><img 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/517737940_58_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_58_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_58_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('53');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=fernverkauf210621&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Online- und Versandhandel - So funktioniert das neue Umsatzsteuerverfahren in der EU" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/fernverkaufsregelung210621.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_53_t_nn.html" title="Mail versenden"><img 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/517737940_53_t_nn.html" title="FB" target="_blank"><img 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/517737940_53_t_nn.html" title="TW" target="_blank"><img 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/517737940_53_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_53_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_53_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('20');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=iab_210201&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Investitionsabzugsbetrag: Ausgaben absetzen, bevor Sie sie getätigt haben" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/iab_210201.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_20_t_nn.html" title="Mail versenden"><img 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/517737940_20_t_nn.html" title="FB" target="_blank"><img 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/517737940_20_t_nn.html" title="TW" target="_blank"><img 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/517737940_20_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_20_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_20_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('49');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=digitalerechnungen201112&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Digitale Rechnungen: So werden sie wie Papierrechnungen anerkannt" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/digitaleRG.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_49_t_nn.html" title="Mail versenden"><img 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/517737940_49_t_nn.html" title="FB" target="_blank"><img 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/517737940_49_t_nn.html" title="TW" target="_blank"><img 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/517737940_49_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_49_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_49_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('43');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kasse200917&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Die aktuellen technischen Anforderungen an elektronische Kassen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Kassenfunktion_191009.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_43_t_nn.html" title="Mail versenden"><img 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/517737940_43_t_nn.html" title="FB" target="_blank"><img 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/517737940_43_t_nn.html" title="TW" target="_blank"><img 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/517737940_43_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_43_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_43_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('40');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=efirmenfahrzeuge_200825&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="E-Fahrzeuge für Mitarbeiter: Neue Steuervergünstigungen für Auto und Jobrad" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/efirmenfahrzeuge190326.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_40_t_nn.html" title="Mail versenden"><img 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/517737940_40_t_nn.html" title="FB" target="_blank"><img 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/517737940_40_t_nn.html" title="TW" target="_blank"><img 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/517737940_40_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_40_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_40_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('46');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=liquiditaet290520&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Liquidität: Mit diesen Maßnahmen bleiben Sie auch bei Umsatzeinbrüchen zahlungsfähig" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/liquiditaet.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_46_t_nn.html" title="Mail versenden"><img 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/517737940_46_t_nn.html" title="FB" target="_blank"><img 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/517737940_46_t_nn.html" title="TW" target="_blank"><img 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/517737940_46_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_46_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_46_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('45');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=steuertundung200327&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Steuerstundung und -herabsetzung: Erleichterungen in der Krise nutzen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/steuerstundung200327.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_45_t_nn.html" title="Mail versenden"><img 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/517737940_45_t_nn.html" title="FB" target="_blank"><img 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/517737940_45_t_nn.html" title="TW" target="_blank"><img 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/517737940_45_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_45_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_45_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('44');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kleinunternehmer_280220&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Kleinunternehmer: Wann Sie von der Umsatzsteuer befreit sind" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/kleinunternehmer_200302.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser44_0">Wenn Sie gerade ein Unternehmen gegründet haben oder im Vorjahr weniger als 22.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.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; 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/517737940_44_t_nn.html" title="Mail versenden"><img 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/517737940_44_t_nn.html" title="FB" target="_blank"><img 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/517737940_44_t_nn.html" title="TW" target="_blank"><img 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/517737940_44_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_44_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_44_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('23');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kassenfuehrung_191213&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Kasse richtig führen: Die neuen Pflichten ab 2020" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/kassenfuehrung2020_191216.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_23_t_nn.html" title="Mail versenden"><img 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/517737940_23_t_nn.html" title="FB" target="_blank"><img 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/517737940_23_t_nn.html" title="TW" target="_blank"><img 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/517737940_23_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_23_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_23_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('14');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=vdkasse151119&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Verfahrensdokumentation für Kassen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/vdkasse191216.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_14_t_nn.html" title="Mail versenden"><img 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/517737940_14_t_nn.html" title="FB" target="_blank"><img 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/517737940_14_t_nn.html" title="TW" target="_blank"><img 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/517737940_14_t_nn.html" title="XI" target="_blank"><img 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/517737940_14_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Verfahrensdokumentation%20für%20Kassen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_14_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_14_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('42');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=leasingkorr_190813_2&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Leasing oder Kauf: Die richtige Entscheidung ohne finanzielle Reue" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/leasing190808.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_42_t_nn.html" title="Mail versenden"><img 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/517737940_42_t_nn.html" title="FB" target="_blank"><img 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/517737940_42_t_nn.html" title="TW" target="_blank"><img 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/517737940_42_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_42_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_42_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('41');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=ersetzendesscannen250619&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Rechnungen digitalisieren: So ersetzt der Scan rechtssicher die Papierrechnung" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/ersetzendesscannen190618.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_41_t_nn.html" title="Mail versenden"><img 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/517737940_41_t_nn.html" title="FB" target="_blank"><img 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/517737940_41_t_nn.html" title="TW" target="_blank"><img 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/517737940_41_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_41_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_41_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('39');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=gutschein220119&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Gutscheine: Wann und in welcher Höhe Umsatzsteuer anfällt" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Gutschein190122a.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_39_t_nn.html" title="Mail versenden"><img 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/517737940_39_t_nn.html" title="FB" target="_blank"><img 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/517737940_39_t_nn.html" title="TW" target="_blank"><img 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/517737940_39_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_39_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_39_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('33');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=dsgvotax110318&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Datenschutzgrundverordnung: Der richtige Umgang mit personenbezogenen Daten" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/DSGVOallg180312.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_33_t_nn.html" title="Mail versenden"><img 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/517737940_33_t_nn.html" title="FB" target="_blank"><img 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/517737940_33_t_nn.html" title="TW" target="_blank"><img 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/517737940_33_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_33_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_33_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('32');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=verfdok_200218&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Verfahrensdokumentation: So müssen Sie Ihre Buchführung für das Finanzamt beschreiben" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/VerfDok180221.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_32_t_nn.html" title="Mail versenden"><img 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/517737940_32_t_nn.html" title="FB" target="_blank"><img 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/517737940_32_t_nn.html" title="TW" target="_blank"><img 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/517737940_32_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_32_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_32_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('30');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kassennachschau201017&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Die neue Kassen-Nachschau: Das sind Ihre Rechte und Pflichten" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/kassenpruefung.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_30_t_nn.html" title="Mail versenden"><img 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/517737940_30_t_nn.html" title="FB" target="_blank"><img 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/517737940_30_t_nn.html" title="TW" target="_blank"><img 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/517737940_30_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_30_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_30_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('29');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=scheinselbstst_270617&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Scheinselbstständigkeit: Die Kriterien und die finanziellen Konsequenzen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/scheinselbststaendig_20170915.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_29_t_nn.html" title="Mail versenden"><img 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/517737940_29_t_nn.html" title="FB" target="_blank"><img 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/517737940_29_t_nn.html" title="TW" target="_blank"><img 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/517737940_29_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_29_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_29_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('5');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=geschenke_140917&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Geschenke an Mitarbeiter und Geschäftspartner: Achten Sie auf diese Steuerfallen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/geschenke_100517.jpg" style="width:300px"></a></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.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; 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/517737940_5_t_nn.html" title="Mail versenden"><img 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/517737940_5_t_nn.html" title="FB" target="_blank"><img 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/517737940_5_t_nn.html" title="TW" target="_blank"><img 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/517737940_5_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_5_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_5_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('8');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=bewirtungskosten_090817&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Bewirtungskosten: So erkennt das Finanzamt Geschäftsessen an" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/bewirtungskosten_10052017.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_8_t_nn.html" title="Mail versenden"><img 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/517737940_8_t_nn.html" title="FB" target="_blank"><img 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/517737940_8_t_nn.html" title="TW" target="_blank"><img 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/517737940_8_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_8_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_8_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('27');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=rechnungen_100517&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Rechnungen: Diese Angaben sind gesetzlich vorgeschrieben" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/rechnungen_100517.jpg" style="width:300px"></a></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. Für die wird rückwirkend ab 1.1.2017 die Grenze auf 250 € angehoben.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; 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/517737940_27_t_nn.html" title="Mail versenden"><img 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/517737940_27_t_nn.html" title="FB" target="_blank"><img 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/517737940_27_t_nn.html" title="TW" target="_blank"><img 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/517737940_27_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_27_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_27_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('15');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=gobd_191216&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Elektronische Buchführung: Diese Regeln müssen alle Selbstständigen beachten" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/GoBD_100517.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_15_t_nn.html" title="Mail versenden"><img 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/517737940_15_t_nn.html" title="FB" target="_blank"><img 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/517737940_15_t_nn.html" title="TW" target="_blank"><img 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/517737940_15_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_15_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_15_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('26');">Künstlersozialabgabe: Diese Abgabe muss fast jeder Selbstständige zahlen</a></td></tr></table></div><div class="videoblock_rubrik" id="26" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile26_0"><a class="anker" id="video26_0"></a>
					<h5 class="videotitel" id="videotitel26_0">Künstlersozialabgabe: Diese Abgabe muss fast jeder Selbstständige zahlen</h5></div>
			<div class="videozeile" id="videozeile26_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=ksk_20170203&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Künstlersozialabgabe: Diese Abgabe muss fast jeder Selbstständige zahlen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/KSK_20170208.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser26_0">Schon 451 € Honorarzahlung an eine Werbeagentur, einen Webdesigner oder andere „Kunstschaffende“ können zur Folge haben, dass Sie Künstlersozialabgabe zahlen müssen. Die Abgabepflicht wird streng geprüft. Oft kommt es zu Nachzahlungen. Wie Sie prüfen, ob Sie abgabepflichtig sind und was dann zu tun ist, erfahren Sie in diesem Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Künstlersozialabgabe:%20Diese%20Abgabe%20muss%20fast%20jeder%20Selbstständige%20zahlen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Künstlersozialabgabe:%20Diese%20Abgabe%20muss%20fast%20jeder%20Selbstständige%20zahlen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_26_t_nn.html" title="Mail versenden"><img 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/517737940_26_t_nn.html" title="FB" target="_blank"><img 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:%20Künstlersozialabgabe:%20Diese%20Abgabe%20muss%20fast%20jeder%20Selbstständige%20zahlen&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_26_t_nn.html" title="TW" target="_blank"><img 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/517737940_26_t_nn.html" title="XI" target="_blank"><img 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/517737940_26_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Künstlersozialabgabe:%20Diese%20Abgabe%20muss%20fast%20jeder%20Selbstständige%20zahlen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_26_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_26_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('16');">EÜR oder Bilanz: Die Vorschriften für die Gewinnermittlung</a></td></tr></table></div><div class="videoblock_rubrik" id="16" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile16_0"><a class="anker" id="video16_0"></a>
					<h5 class="videotitel" id="videotitel16_0">EÜR oder Bilanz: Die Vorschriften für die Gewinnermittlung</h5></div>
			<div class="videozeile" id="videozeile16_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=bilanz_171215&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="EÜR oder Bilanz: Die Vorschriften für die Gewinnermittlung" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Bilanzeur_20170113.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser16_0">Es gibt zwei Methoden, mit denen Selbstständige und Unternehmen den Gewinn ermitteln können: Die Einnahmenüberschussrechnung (EÜR) und die Bilanz. Wer darf welche Methode nutzen und welche Vor- und Nachteile sind damit verbunden?

			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=EÜR%20oder%20Bilanz:%20Die%20Vorschriften%20für%20die%20Gewinnermittlung&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'EÜR%20oder%20Bilanz:%20Die%20Vorschriften%20für%20die%20Gewinnermittlung'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_16_t_nn.html" title="Mail versenden"><img 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/517737940_16_t_nn.html" title="FB" target="_blank"><img 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ÜR%20oder%20Bilanz:%20Die%20Vorschriften%20für%20die%20Gewinnermittlung&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_16_t_nn.html" title="TW" target="_blank"><img 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/517737940_16_t_nn.html" title="XI" target="_blank"><img 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/517737940_16_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«EÜR%20oder%20Bilanz:%20Die%20Vorschriften%20für%20die%20Gewinnermittlung»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_16_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_16_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('1');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=kassenbuch_010117&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Kassenbuch: Die 5 gefährlichsten Steuerfallen - und wie Sie sie vermeiden" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Kassenbuch_20170113.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_1_t_nn.html" title="Mail versenden"><img 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/517737940_1_t_nn.html" title="FB" target="_blank"><img 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/517737940_1_t_nn.html" title="TW" target="_blank"><img 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/517737940_1_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_1_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_1_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('25');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=erbschaftsteuer_151116&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Erbschaftsteuer: Wann die Steuer greift und wie Sie Befreiungen nutzen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/erbschaftsteuerreform_20161116.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_25_t_nn.html" title="Mail versenden"><img 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/517737940_25_t_nn.html" title="FB" target="_blank"><img 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/517737940_25_t_nn.html" title="TW" target="_blank"><img 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/517737940_25_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_25_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_25_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('12');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=steuerschuldnerschaft_290914&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Umkehr der Steuerschuldnerschaft: Wann der Rechnungsempfänger die Umsatzsteuer zahlen muss" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Ustumkehr_20170113.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_12_t_nn.html" title="Mail versenden"><img 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/517737940_12_t_nn.html" title="FB" target="_blank"><img 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/517737940_12_t_nn.html" title="TW" target="_blank"><img 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/517737940_12_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_12_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_12_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('52');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=progression270521&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Steuerfalle Progressionsvorbehalt – Wann steuerfreie Einnahmen zu Steuernachzahlungen führen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/progressionsvorbehalt.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_52_t_nn.html" title="Mail versenden"><img 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/517737940_52_t_nn.html" title="FB" target="_blank"><img 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/517737940_52_t_nn.html" title="TW" target="_blank"><img 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/517737940_52_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_52_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_52_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('31');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=doppeltehaushalt_080118&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Doppelte Haushaltsführung: So machen Sie Kosten für einen zweiten Wohnsitz steuerlich geltend" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/doppelhf20180109.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_31_t_nn.html" title="Mail versenden"><img 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/517737940_31_t_nn.html" title="FB" target="_blank"><img 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/517737940_31_t_nn.html" title="TW" target="_blank"><img 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/517737940_31_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_31_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_31_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('21');">Aushilfsjobs: Günstige Beschäftigungen mit Mini- und Kurzfristjobs</a></td></tr></table></div><div class="videoblock_rubrik" id="21" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile21_0"><a class="anker" id="video21_0"></a>
					<h5 class="videotitel" id="videotitel21_0">Aushilfsjobs: Günstige Beschäftigungen mit Mini- und Kurzfristjobs</h5></div>
			<div class="videozeile" id="videozeile21_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=aushilfen_090717&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Aushilfsjobs: Günstige Beschäftigungen mit Mini- und Kurzfristjobs" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/Aushilfen_27052016.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser21_0">Für Aushilfsbeschäftigungen gibt es Vergünstigungen bei Steuern und Sozialabgaben. Dieses Video zeigt, welche es sind und wie Sie sie nutzen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Aushilfsjobs:%20Günstige%20Beschäftigungen%20mit%20Mini-%20und%20Kurzfristjobs&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Aushilfsjobs:%20Günstige%20Beschäftigungen%20mit%20Mini-%20und%20Kurzfristjobs'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_21_t_nn.html" title="Mail versenden"><img 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/517737940_21_t_nn.html" title="FB" target="_blank"><img 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:%20Aushilfsjobs:%20Günstige%20Beschäftigungen%20mit%20Mini-%20und%20Kurzfristjobs&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_21_t_nn.html" title="TW" target="_blank"><img 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/517737940_21_t_nn.html" title="XI" target="_blank"><img 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/517737940_21_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Aushilfsjobs:%20Günstige%20Beschäftigungen%20mit%20Mini-%20und%20Kurzfristjobs»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_21_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_21_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('18');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=lohnsteuererm_261015&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Lohnsteuerermäßigung: So erhöhen Sie Ihren monatlichen Nettolohn" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/lohnsteuererm_10052017.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser18_0">Mit einem Lohnsteuerermäßigungsantrag können Sie Steuerermäßigungen direkt bei der Lohnabrechnung berücksichtigen lassen. So erhöhen Sie Ihren monatlichen Nettolohn. Seit dem 1.10.2015 können Sie Ermäßigungen für zwei Jahre beantragen. In diesem Video erfahren Sie, wie Sie vorgehen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; 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/517737940_18_t_nn.html" title="Mail versenden"><img 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/517737940_18_t_nn.html" title="FB" target="_blank"><img 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/517737940_18_t_nn.html" title="TW" target="_blank"><img 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/517737940_18_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_18_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_18_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('4');">Kostenpauschalen: Diese Werbungskosten verringern Ihre Steuer - auch ohne Beleg</a></td></tr></table></div><div class="videoblock_rubrik" id="4" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile4_0"><a class="anker" id="video4_0"></a>
					<h5 class="videotitel" id="videotitel4_0">Kostenpauschalen: Diese Werbungskosten verringern Ihre Steuer - auch ohne Beleg</h5></div>
			<div class="videozeile" id="videozeile4_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=werbungskpausch_200714&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Kostenpauschalen: Diese Werbungskosten verringern Ihre Steuer - auch ohne Beleg" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/kostenpauschalen191216.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser4_0">Als Arbeitnehmer dürfen Sie Ausgaben für Ihren Beruf von der Steuer absetzen. Für manche Ausgaben müssen Sie dem Finanzamt nicht einmal eine Rechnung vorlegen. Diese pauschalen Werbungskosten sollten Sie kennen.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Kostenpauschalen:%20Diese%20Werbungskosten%20verringern%20Ihre%20Steuer%20-%20auch%20ohne%20Beleg&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Kostenpauschalen:%20Diese%20Werbungskosten%20verringern%20Ihre%20Steuer%20-%20auch%20ohne%20Beleg'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_4_t_nn.html" title="Mail versenden"><img 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/517737940_4_t_nn.html" title="FB" target="_blank"><img 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:%20Kostenpauschalen:%20Diese%20Werbungskosten%20verringern%20Ihre%20Steuer%20-%20auch%20ohne%20Beleg&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_4_t_nn.html" title="TW" target="_blank"><img 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/517737940_4_t_nn.html" title="XI" target="_blank"><img 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/517737940_4_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Kostenpauschalen:%20Diese%20Werbungskosten%20verringern%20Ihre%20Steuer%20-%20auch%20ohne%20Beleg»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_4_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_4_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('24');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=steuerklassenwahl_250416&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Lohnsteuerklassen: Wie Sie durch die richtige Wahl mehr Nettolohn und Ersatzleistungen erhalten" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/steuerklassen_29042016.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_24_t_nn.html" title="Mail versenden"><img 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/517737940_24_t_nn.html" title="FB" target="_blank"><img 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/517737940_24_t_nn.html" title="TW" target="_blank"><img 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/517737940_24_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_24_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_24_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('57');">Grundsteuererklärung - Welche Fragen das Finanzamt stellt und wo Sie die Antworten finden</a></td></tr></table></div><div class="videoblock_rubrik" id="57" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile57_0"><a class="anker" id="video57_0"></a>
					<h5 class="videotitel" id="videotitel57_0">Grundsteuererklärung - Welche Fragen das Finanzamt stellt und wo Sie die Antworten finden</h5></div>
			<div class="videozeile" id="videozeile57_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=grstunterl_220404&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Grundsteuererklärung - Welche Fragen das Finanzamt stellt und wo Sie die Antworten finden" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/grundsteuerunterlagen.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser57_0">Ab Juli 2022 muss für jedes Grundstück eine Erklärung an das Finanzamt abgegeben werden. Das übernehmen wir gerne für Sie. Dafür brauchen wir einige Angaben. In welchen Unterlagen Sie die finden, zeigt dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Grundsteuererklärung%20-%20Welche%20Fragen%20das%20Finanzamt%20stellt%20und%20wo%20Sie%20die%20Antworten%20finden&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Grundsteuererklärung%20-%20Welche%20Fragen%20das%20Finanzamt%20stellt%20und%20wo%20Sie%20die%20Antworten%20finden'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_57_t_nn.html" title="Mail versenden"><img 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/517737940_57_t_nn.html" title="FB" target="_blank"><img 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:%20Grundsteuererklärung%20-%20Welche%20Fragen%20das%20Finanzamt%20stellt%20und%20wo%20Sie%20die%20Antworten%20finden&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_57_t_nn.html" title="TW" target="_blank"><img 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/517737940_57_t_nn.html" title="XI" target="_blank"><img 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/517737940_57_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Grundsteuererklärung%20-%20Welche%20Fragen%20das%20Finanzamt%20stellt%20und%20wo%20Sie%20die%20Antworten%20finden»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_57_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_57_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('56');">Grundsteuerreform - Was sich für Eigentümer ändert und wie viel Sie künftig zahlen müssen</a></td></tr></table></div><div class="videoblock_rubrik" id="56" style="display:none;"><div class="videoblock"><div class="titelzeile" id="titelzeile56_0"><a class="anker" id="video56_0"></a>
					<h5 class="videotitel" id="videotitel56_0">Grundsteuerreform - Was sich für Eigentümer ändert und wie viel Sie künftig zahlen müssen</h5></div>
			<div class="videozeile" id="videozeile56_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=grundsteuerreform_211111&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Grundsteuerreform - Was sich für Eigentümer ändert und wie viel Sie künftig zahlen müssen" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/grundsteuerreform_211111.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser56_0">Ab 1.1.2022 startet die Grundsteuerreform. Schon bald müssen Immobilienbesitzer eine Grundsteuererklärung abgeben, mit der der Grundstückswert neu berechnet wird. Wie die Grundsteuer künftig ermittelt wird, zeigt dieses Video.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Grundsteuerreform%20-%20Was%20sich%20für%20Eigentümer%20ändert%20und%20wie%20viel%20Sie%20künftig%20zahlen%20müssen&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Grundsteuerreform%20-%20Was%20sich%20für%20Eigentümer%20ändert%20und%20wie%20viel%20Sie%20künftig%20zahlen%20müssen'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_56_t_nn.html" title="Mail versenden"><img 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/517737940_56_t_nn.html" title="FB" target="_blank"><img 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:%20Grundsteuerreform%20-%20Was%20sich%20für%20Eigentümer%20ändert%20und%20wie%20viel%20Sie%20künftig%20zahlen%20müssen&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_56_t_nn.html" title="TW" target="_blank"><img 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/517737940_56_t_nn.html" title="XI" target="_blank"><img 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/517737940_56_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Grundsteuerreform%20-%20Was%20sich%20für%20Eigentümer%20ändert%20und%20wie%20viel%20Sie%20künftig%20zahlen%20müssen»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_56_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_56_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('55');">Photovoltaikanlagen: Was Sie bei der Steuer beachten sollten </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: Was Sie bei der Steuer beachten sollten </h5></div>
			<div class="videozeile" id="videozeile55_0"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=pvanlagen_211006&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Photovoltaikanlagen: Was Sie bei der Steuer beachten sollten " data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/pvanlagen211007.jpg" style="width:300px"></a></div><br/>	
			<div class="teaser" id="teaser55_0">Immobilienbesitzer und auch Mieter entscheiden sich immer öfter für Photovoltaikanlagen. Dabei spielen nicht nur Umweltaspekte eine Rolle. Als Betreiber profitieren Sie auch von steuerlichen Vorteilen, müssen allerdings auch Pflichten beachten. In diesem Video erfahren Sie, welche das sind.
			</div>
			<div style="margin-top: 10px; margin-bottom:20px;" class="sharebuttons-element sharebuttons-size-16"><div class="empfehlungshinweis" style="line-height:250%; font-size:80%; display: block;">Hat Ihnen das Video geholfen? Dann empfehlen Sie es bitte weiter!</div><a class="smb" href="mailto:?subject=Photovoltaikanlagen:%20Was%20Sie%20bei%20der%20Steuer%20beachten%20sollten%20&amp;body=Hallo,%0D%0Aich%20empfehle%20Dir/Ihnen%20das%20Video%20'Photovoltaikanlagen:%20Was%20Sie%20bei%20der%20Steuer%20beachten%20sollten%20'.%0D%0ADas%20Video%20ist%20auf%20der%20Homepage%20meines%20Steuerberaters%20unter%20folgender%20Adresse%20aufrufbar:%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_55_t_nn.html" title="Mail versenden"><img 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/517737940_55_t_nn.html" title="FB" target="_blank"><img 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:%20Was%20Sie%20bei%20der%20Steuer%20beachten%20sollten%20&url=https://www.mandantenvideo.de/commons/empfehlungen/517737940_55_t_nn.html" title="TW" target="_blank"><img 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/517737940_55_t_nn.html" title="XI" target="_blank"><img 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/517737940_55_t_nn.html&title=Videotipp&summary=Ich%20empfehle%20das%20Video%20«Photovoltaikanlagen:%20Was%20Sie%20bei%20der%20Steuer%20beachten%20sollten%20»%20->%20https://www.mandantenvideo.de/commons/empfehlungen/517737940_55_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_55_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('35');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=immobilienco110918&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Verkauf von Immobilien & Co. - Wann Steuern anfallen und wie Sie sie vermeiden" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/privVeraeusserung_180908.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_35_t_nn.html" title="Mail versenden"><img 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/517737940_35_t_nn.html" title="FB" target="_blank"><img 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/517737940_35_t_nn.html" title="TW" target="_blank"><img 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/517737940_35_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_35_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_35_t_nn.html" title="LI" target="_blank"><img 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="videosymbol" alt="Videosymbol" src="https://www.deubner-online.de/einbau/taxplain/videopages/images/videosymbol.png"></td><td class="videotitel"><a href="javascript:toggleDiv('34');">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"><a href="https://www.mandantenvideo.de/commons/bin_videos/videoshow_simple.html?video=vermietang201211&autostart=1&kdnr=517737940&v_modus=0&service=taxplain" class="lytebox" data-title="Vermietung an Angehörige: So erkennt das Finanzamt günstige Gestaltungen an" data-lyte-options="width:800 height:600 scrollbars:no theme:grey" rel="nofollow"><img class="vorschaubild" alt="Vorschaubild" src="https://www.deubner-online.de/taxplain/videopages/images/vermAngeh180605.jpg" style="width:300px"></a></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="line-height:250%; 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/517737940_34_t_nn.html" title="Mail versenden"><img 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/517737940_34_t_nn.html" title="FB" target="_blank"><img 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/517737940_34_t_nn.html" title="TW" target="_blank"><img 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/517737940_34_t_nn.html" title="XI" target="_blank"><img 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/517737940_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/517737940_34_t_nn.html&source=https://www.mandantenvideo.de/commons/empfehlungen/517737940_34_t_nn.html" title="LI" target="_blank"><img 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/><!--VNR=0--></div> 
Wir beraten Sie gerne
Telefon: (0 23 04) – 59 75 09-0
info@kanzlei-justus.de
Unsere Bürozeiten
Montag-Donnerstag: 9 – 17 Uhr
Freitag: 9 – 15 Uhr
sowie nach Vereinbarung