array (
  0 => 'http://img164.echo.cx/img164/2331/cerkiew32dz.jpg',
  1 => '/var/www/vhosts/knives.pl/subdomains/img/httpdocs/proxy/cache/55e42295520f2a049de33c879def1147ce7cbb0e9e10132c7339145fa772ec9f/origin.jpg',
  2 => false,
)<br />
<b>Warning</b>:  Trying to access array offset on value of type bool in <b>/var/www/vhosts/knives.pl/subdomains/img/httpdocs/proxy/index.php</b> on line <b>182</b><br />
<!DOCTYPE html>
<html lang="fr">	
	<head>
		<meta charset="utf-8"/> 
		
		<title>Banque en Ligne 2024 - Le guide étape par étape pour choisir facilement</title>
		<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"/> 
		<meta name="description" content="Meilleur service client, taux d’interêt et offre de bienvenue ? Trouvez la banque en ligne qui vous convient grâce à notre comparatif/guide et économisez en moyenne 150 euros par an !" />
	
	</head>
	<body>
		<div class="introduction-block block">
			<div class="container">
				<h1>Le guide pour choisir facilement sa banque en ligne</h1>
				
				<div class="row">
					<div class="col-md-6">
						<img src="img/introduction/comparateur-banque-en-ligne.jpg" class="img-responsive" alt="Banque en ligne">
					</div>
					<div class="col-md-6">
						<ul>
							<li><strong>150 euros d’économie</strong> en moyenne par an (<abbr title="Carte Bancaire">CB</abbr> gratuite, frais bancaires réduits...)</li>
							<li><strong>11% des francais</strong> ont une banque en ligne</li>
							<li>Des conseillers disponibles de <strong>8h à 22h</strong> en moyenne du <strong>Lundi au Samedi</strong></li>
							<li><strong>Des supers livrets</strong> aux rendements boostés</li>
							<li>Une offre de bienvenue de <strong>80 euros</strong> en moyenne</li>
						</ul>
						
						<a href="#more" class="btn btn-default btn-lg">En savoir plus</a>
					</div>
				</div>
			</div>
		</div>
		<div class="toc-block block" id="more">
			<div class="container">
				<div class="row">
					<div class="col-md-2 col-md-offset-2">
						<img src="img/toc/choisir-banque.jpg" class="img-responsive img-full-width" alt="Choisir sa banque">
					</div>
					<div class="col-md-7">
						<p>
							Avec l’essor du Web, la banque virtuelle a connu un véritable succès, car elle présente de nombreux avantages&nbsp;: simplicité, frais réduits, interactivité… 
							Certains consommateurs sont encore réfractaires, pourtant les atouts sont présents. Les différentes opérations seront effectuées en ligne avec un maximum de sécurité. 
							Toutes les offres nécessaires au quotidien sont aussi au rendez-vous, une telle banque peut donc vous changer la vie.
						</p>
						
						<hr />
						<strong>Sommaire</strong>
						<ol class="main">
							<li><a href="#a000">Qu’est-ce qu’une banque en ligne&nbsp;?</a></li>
							<li><a href="#b000">À qui s’adresse une banque online&nbsp;?</a></li>
							<li>
								<a href="#c000">Pourquoi choisir une banque en ligne plutôt qu’une banque traditionnelle&nbsp;?</a>
								<ol>
									<li><a href="#c100">Les trois avantages qui vous vont séduire</a>
										<ol>
											<li><a href="#c110">Gagner du temps en fuyant les files d’attente</a></li>
											<li><a href="#c120">Une gestion simplifiée de toutes les opérations</a></li>
											<li><a href="#c130">La baisse, voire la suppression des frais bancaires</a></li>
										</ol>
									</li>
									<li><a href="#c200">Les trois inconvénients les plus gênants</a>
										<ol>
											<li><a href="#c210">Pas de conseiller physique, mais un conseiller virtuel</a></li>
											<li><a href="#c220">Une inscription validée selon les revenus</a></li>
											<li><a href="#c230">La complexité de déposer de l’argent liquide</a></li>
										</ol>
									</li>		
								</ol>		
							</li>
							<li><a href="#d000">La banque en ligne est-elle faite pour vous&nbsp;?</a>
								<ol>
									<li><a href="#d100">Je veux économiser de l’argent</a></li>
									<li><a href="#d200">Je ne suis pas contre l’autonomie</a></li>
									<li><a href="#d300">J’ai des revenus adaptés</a></li>
								</ol>
							</li>
							<li><a href="#e000">Comment se passe le passage d’une banque traditionnelle vers une banque «&nbsp;virtuelle&nbsp;»&nbsp;?</a>
								<ol>
									<li><a href="#e100">L’ouverture du compte en ligne</a>
										<ol>
											<li><a href="#e110">Quels sont les documents nécessaires pour ouvrir un compte en ligne&nbsp;?</a></li>
										</ol>
									</li>
									<li><a href="#e200">Le transfert automatique vers la nouvelle banque</a></li>
									<li><a href="#e300">La clôture de l’ancien compte</a></li>
								</ol>
							</li>
							<li><a href="#f000">Combien de clients ont adopté ces nouvelles banques en ligne&nbsp;?</a>
								<ol>
									<li><a href="#f100">Une progression de 4 points en 6 mois</a></li>
									<li><a href="#f200">Boursorama Banque est leader sur le marché</a></li>
									<li><a href="#f300">Demain, la progression sera encore plus fulgurante</a></li>
								</ol>
							</li>
							<li><a href="#g000">Doit-on avoir peur du piratage informatique&nbsp;?</a>
								<ol>
									<li><a href="#g100">Utilisation d’un clavier numérique inviolable</a></li>
									<li><a href="#g200">Les données sont cryptées avant d’être transférées</a></li>
									<li><a href="#g300">Un code spécial pour certaines opérations</a></li>
								</ol>
							</li>	
							<li><a href="#h000">Les applications mobiles et les banques en ligne</a>
								<ol>
									<li><a href="#h100">Une compatibilité avec iOS, Windows Phone et Android</a></li>
									<li><a href="#h200">Les 5 fonctionnalités les plus intéressantes</a></li>
									<li><a href="#h300">Une application mobile est plus attractive qu’un site mobile</a></li>
									<li><a href="#h400">Soon, une banque 100% mobile</a></li>
								</ol>
							</li>	
							<li><a href="#i000">Quelles sont les banques en ligne disponibles&nbsp;?</a>
								<ol>
									<li><a href="#i100">Quelle est la différence entre une banque en ligne et une version hybride&nbsp;?</a></li>
									<li><a href="#i200">Six banques en ligne sont à la disposition des clients</a></li>
								</ol>
							</li>	
							<li><a href="#j000">Quels sont les produits proposés par les banques en ligne&nbsp;?</a></li>
							<li><a href="#k000">Les banques en ligne sont-elles adaptées aux professionnels&nbsp;?</a>
								<ol>
									<li><a href="#k100">Un choix idéal pour les petites entreprises</a></li>
									<li><a href="#k200">Quels sont les documents nécessaires pour ouvrir son compte&nbsp;?</a></li>
								</ol>
							</li>
							<li><a href="#l000">Quelques conseils pour réussir son expérience avec une banque en ligne</a>
								<ol>
									<li><a href="#l100">Accepter les alertes personnalisées</a></li>
									<li><a href="#l200">Apprendre à utiliser toutes les technologies</a></li>
									<li><a href="#l300">Sécuriser la connexion avec un vrai mot de passe</a>
										<ol>
											<li><a href="#l310">Comment sécuriser son compte de banque en ligne&nbsp;?</a></li>
										</ol>
									</li>	
								</ol>
							</li>
							<li><a href="#m000">FAQ</a>
								<ol>
									<li><a href="#m100">Pourquoi les prix sont-ils si bas&nbsp;? Les banques en ligne sont-elles légales&nbsp;?</a></li>
									<li><a href="#m200">Les banques en ligne sont-elles sérieuses&nbsp;?</a></li>
									<li><a href="#m300">Pourrais-je parler à un conseiller&nbsp;?</a></li>
									<li><a href="#m400">Comment effectuer des virements&nbsp;?</a></li>
									<li><a href="#m500">Comment déposer des chèques&nbsp;?</a></li>
									<li><a href="#m600">Comment retirer de l’argent&nbsp;?</a></li>
									<li><a href="#m700">Comment choisir une banque en ligne&nbsp;?</a></li>
									<li><a href="#m800">Une banque en ligne autorise-t-elle les crédits&nbsp;?</a></li>
									<li><a href="#m900">Vais-je réaliser des économies&nbsp;?</a></li>
									<li><a href="#m1000">L’épargne est-elle plus intéressante avec une banque en ligne&nbsp;?</a></li>
									<li><a href="#m1100">Les incidents bancaires sont-ils plus avantageux&nbsp;?</a></li>
									<li><a href="#m1200">Les banques en ligne délivrent-elles un chèque de banque&nbsp;?</a></li>
									<li><a href="#m1300">Quelle est leur politique en matière de carte sans contact&nbsp;?</a></li>
								</ol>
							</li>	
						</ol>
					</div>
				</div>
				
			</div>
			
					</div>
		
		<div class="a-block block blue-block">
			<div class="container">
				<h2 id="a000">Qu’est-ce qu’une banque en ligne&nbsp;?</h2>
				<div class="row">
					<div class="col-md-5 col-md-offset-1">
						<p>
							Elle se dévoile sous plusieurs appellations, mais le procédé reste similaire. 
							<strong>Une banque virtuelle permet de gérer toutes les opérations via le Web en supprimant tous les frais généralement facturés 
							par un établissement physique.</strong> Les premières versions étaient réservées à un public averti, car seuls les amateurs 
							de courtage en bourse étaient séduits. Dans les années 2000, la baisse du pouvoir d’achat a eu une répercussion 
							non négligeable sur le quotidien des Français. L’offre a donc été adaptée, c’est de cette manière que la banque online a vu le jour.
						</p>
						<p>
							Si certains acteurs sont spécialisés uniquement dans ce secteur comme Hello Bank ou Fortuneo, 
							d’autres ont décidé d’investir le marché en diffusant une formule spécialement pensée pour le Web. 
							Le format en ligne s’est démocratisé puisque les banques LCL et BNP Paribas se sont penchées 
							sur un format 100% en ligne et surtout 100% sécurisé.
						</p>
					</div>
					<div class="col-md-5">
						<p>
							Même si l’e-banque fonctionne uniquement sur internet, elle met en avant tout le nécessaire pour combler les attentes d’un consommateur. 
							Il aura à sa disposition une multitude de produits&nbsp;: livrets d’épargne, carte bancaire, chéquier, crédits… 
							Contrairement aux idées reçues, <strong>il n’y a pratiquement aucune différence en terme de produits, les services et les prestations 
							(tenue de compte, financement, placements…) sont généralement très proches.</strong>
						</p>
						<p>
							<strong>La plus grande différence s’articule autour de l’absence d’agences physiques et une baisse extrêmement élevée des coûts.</strong>
							Il serait dommage de ne pas profiter d’un même catalogue tout en effectuant des économies. Si certains consommateurs 
							ne souhaitent pas se lancer immédiatement dans une banque totalement digitale, il existe une version semi-digitale 
							puisque Hello Bank appartient à BNP Paribas. Il sera donc possible d’avoir les avantages dans les deux domaines.
						</p>
					</div>
				</div>
			</div>
		</div>
		<div class="b-block block">
			<div class="container">
				<h2 id="b000">À qui s’adresse une banque online&nbsp;?</h2>
				
				<div class="row">
					<div class="col-md-10 col-md-offset-1">
						<p>
							C’est sans doute une bonne nouvelle puisqu’<strong>il n’y a aucune restriction en matière de profils</strong>. 
							Tous les consommateurs sont les bienvenus, les banques en ligne ont su adapter leur catalogue aux besoins. 
							Un particulier ainsi qu’un professionnel seront en mesure de sélectionner une offre susceptible de répondre 
							à leurs attentes que ce soit pour un crédit auto, une solution d’épargne, une assurance…
						<p>
						
						<p>
							Par conséquent, toutes les personnes physiques et majeures qui résident en France métropolitaine ont la possibilité 
							d’ouvrir un compte. Les conditions d’éligibilités ne sont pas plus restrictives qu’un établissement classique. 
							Dans certains cas de figure, il sera nécessaire de justifier d’un revenu minimum mensuel et ne pas avoir 
							fait l’objet d’un incident bancaire. Avec une adresse mail, un numéro de téléphone et quelques documents, 
							l’ouverture d’un compte chez une banque virtuelle s’effectue en quelques clics&nbsp;!
						</p>
						
						<p>	
							Tous les profils sont ainsi comblés, une telle banque convient aux nouvelles générations qui souhaitent supprimer 
							les contraintes d’un établissement bancaire, aux anciennes générations qui ont la volonté d’économiser en réduisant 
							drastiquement les frais bancaires ou ceux qui ont la volonté de jongler avec une réelle aisance entre plusieurs comptes.
						</p>
						
						<p>
							La clientèle s’est même élargie au fil des années puisque les jeunes ont succombé aux charmes des banques en ligne 
							selon le <a href="https://www.simon-kucher.com/fr">cabinet Simon Kucher & Partners</a>. 35.6% des 25/39 ans ont décidé de rejoindre les rangs contre 34.3% des 40/54 ans. 
							Les hommes sont également les premiers à être attirés par ces comptes 100% en ligne, ils sont 62.7% contre 37.3% de femmes. 
							Mis à part l’âge, la cible a également été modifiée, car, même si 70.3% des clients ont tendance à jouir d’un revenu supérieur 
							à 2000 euros, il y a tout de même 26.5% d’employés et 25.8% de cadres et professions intellectuelles.
						</p>
					</div>
				</div>			
			</div>
		</div>	
		<div class="c-block block">
			<div class="container">
				<h2 id="c000">Pourquoi choisir une banque en ligne plutôt qu’une banque traditionnelle&nbsp;?</h2>
				
				<h3 id="c100">Les trois avantages qui vous vont séduire</h3>
				<div class="row">
					<div class="col-md-4">
						<img src="img/c/file-attente-banque.jpg" class="img-responsive" alt="Gagner du temps">
						<h4 id="c110">Gagner du temps en fuyant les files d’attente</h4>
						<p>
							Inutile de se déplacer à un guichet puisque toutes les transactions (virements, prélèvements…) 
							seront effectuées depuis le compte en ligne. Cela offre un gain de temps généralement très important, 
							car l’attente dans un établissement est longue surtout pendant les heures de pointe. 
							Ces précieuses minutes gagnées pourront être utilisées à bon escient. 
						</p>
					</div>
					<div class="col-md-4">
						<img src="img/c/operation-bancaire-simple.jpg" class="img-responsive" alt="opérations simplifiée">
						<h4 id="c120">Une gestion simplifiée de toutes les opérations</h4>
						<p>
							L’utilisation est aussi simple, il suffit de piloter son compte depuis une interface intuitive. 
							En quelques clics, le virement est envoyé, l’argent a été versé sur l’épargne, un <abbr title="Relevé d'Identité Bancaire">RIB</abbr> a été imprimé… 
							Toutes les actions offertes par un établissement physiques sont au rendez-vous sans les désagréments. 
							La banque en ligne propose ainsi un confort d’utilisation et une réelle souplesse tout en mettant 
							en avant des innovations avec le portefeuille électronique ou le coffre-fort virtuel.
						</p>
					</div>
					<div class="col-md-4">
						<img src="img/c/aucun-frais.jpg" class="img-responsive" alt="suppression des frais bancaires">
						<h4 id="c130">La baisse, voire la suppression des frais bancaires</h4>
						<p>
							Ils vous permettront sans aucun doute de gagner du pouvoir d’achat, car, par rapport 
							aux banques traditionnelles, le grand plongeon est assuré. Alors que ces dernières 
							demandent une somme colossale pour la carte bancaire ou l’ouverture d’un compte, 
							la banque online a le mérite de n’appliquer aucun frais supplémentaire, la gestion coûte 
							dans la plupart des cas zéro euro, ce qui est impensable dans une enseigne physique. 
							En parallèle, toutes les opérations seront effectuées gratuitement.
						</p>
					</div>
				</div>

				<h3 id="c200">Les trois inconvénients les plus gênants</h3>
				<div class="row">
					<div class="col-md-4">
						<img src="img/c/conseiller.jpg" class="img-responsive" alt="absence de conseiller physique">
						<h4 id="c210">Pas de conseiller physique, mais un conseiller virtuel</h4>
						<p>
							Les atouts sont nombreux, mais il est difficile d’être parfait, il existe donc des points faibles. 
							Le premier est une conséquence du gain de temps. En effet, en fuyant les files d’attente et les guichets, 
							vous perdrez un contact humain. Cela n’empêche pas les banques en ligne de mettre à 
							votre disposition des conseillers financiers.
						</p>	

						<p>
							Ils seront joignables selon les heures établies par mail, au téléphone ou via un tchat. 
							Vous ne serez donc pas perdu dans ce monde virtuel, mais des personnes apprécient ce contact humain 
							qui sera immédiatement supprimé puisque ces banques à distance n’ont pas de locaux. 
							Même si vous souhaitez avoir un conseil régulier, les plateformes s’adapteront à vos envies.
						</p>
					</div>
					<div class="col-md-4">
						<img src="img/c/ouvrir-un-compte.jpg" class="img-responsive" alt="inscription selon les revenus">
						<h4 id="c220">Une inscription validée selon les revenus</h4>
						<p>
							Le second inconvénient peut représenter un frein particulier pour certains foyers. 
							En effet, pour réduire au maximum les frais, voire les supprimer, les banques sont contraintes 
							d’appliquer des conditions d’entrée. Elles ne sont pas nombreuses, elles s’articulent seulement autour des revenus.
						</p>	

						<p>
							Des plateformes comme Fortuneo demanderont la justification de revenus de l’ordre de 1500 euros. 
							D’autres enseignes ont décidé de couper la poire en deux, c’est le cas chez ING Direct. Toutefois, 
							Monabanq a même décidé de lever cette restriction, mais, en contrepartie, des frais seront générés 
							tous les mois notamment pour la carte bancaire.
						</p>
					</div>
					<div class="col-md-4">
						<img src="img/c/depot-liquide.jpg" class="img-responsive" alt="déposer de l’argent liquide">
						<h4 id="c230">La complexité de déposer de l’argent liquide</h4>
						<p>
							Si vous avez tendance à avoir du cash régulièrement dans votre poche, vous ne pourrez pas le déposer 
							dans une banque en ligne avec autant de facilité. À nouveau, cet inconvénient sera balayé d’un revers 
							de la main pour ceux qui se focalisent sur les échanges d’argent via les versements. En parallèle, 
							vous pourrez tout de même opter pour un mandat cash dont les frais seront à votre portée.
						</p>	

						<p>
							Hello Bank a toutefois eu la bonne idée de vous permettre de déposer vos billets dans les établissements 
							de BNP Paribas, comme il s’agit d’une filiale, la gestion est un peu plus souple. 
							Par rapport aux atouts, la liste n’est donc pas exhaustive, mais il est nécessaire d’évoquer les inconvénients 
							pour être totalement transparents dans notre démarche de vous accompagner.
						</p>
					</div>
				</div>
				
				<table class="table table-striped table-simple">
					<thead>
						<tr>
							<th>
								Vous aimerez avec une banque en ligne
							</th>
							<th>
								Vous aimerez moins
							</th>
						</tr>					
					</thead>
					<tbody>
						<tr>
							<td>La souplesse d’utilisation de la plateforme</td>
							<td>Le manque de contact humain</td>
						</tr>
						<tr>
							<td>Le gain de temps&nbsp;: plus d’attente interminable&nbsp;!</td>
							<td>Les restrictions en matière de revenus</td>
						</tr>
						<tr>
							<td>La chute des frais bancaires</td>
							<td>Le dépôt de l’argent liquide est complexe</td>
						</tr>
						<tr>
							<td>La rémunération élevée des livrets</td>
							<td>La migration de votre compte classique</td>
						</tr>
						<tr>
							<td>La fiabilité des banques à distance</td>
							<td></td>
						</tr>
						<tr>
							<td>Les produits sécurisés</td>
							<td></td>
						</tr>
						<tr>
							<td>L’offre complète</td>
							<td></td>
						</tr>
						<tr>
							<td>Le coffre-fort électronique pour conserver des documents</td>
							<td></td>
						</tr>
					</tbody>
				</table>
				
			</div>
		</div>
		
		<div class="d-block block">
			<div class="container">
			 	<h2 id="d000">La banque en ligne est-elle faite pour vous&nbsp;?</h2>
			
				<div class="row">
					<div class="col-md-6">
						<div class="scrollable">
							<div class="movable">
								<h3 id="d100">Je veux économiser de l’argent</h3>
								<p>
									Le marché connaît un fort engouement, cela s’explique par tous les avantages et le peu d’inconvénients 
									listés au préalable. Vous pouvez toutefois hésiter à sauter le pas à cause d’une multitude d’interrogations. 
									De plus en plus de Français ont recours à cette banque à distance, ils sont plusieurs millions à avoir délaissé 
									leur compte courant pour choisir la simplicité. Les avis positifs sont également très rassurants, 
									ce qui permet à plusieurs plateformes de connaître une véritable envolée.
								</p>
								<p>
									<strong>La banque en ligne est faite pour vous si vous en avez assez de payer des frais de plus en plus 
									importants dès que vous effectuez une démarche</strong>&nbsp;: retrait dans un autre distributeur, 
									émission d’un virement ponctuel, la gestion, la demande d’un chèque de banque, 
									la transmission régulière des relevés de compte…
								</p>
	
								<p>
									Les établissements physiques tentent de rentabiliser les locaux, ils utilisent donc la meilleure arme à savoir 
									les frais bancaires. Généralement, l’économie n’est pas négligeable, car elle s’articule autour de 35, 
									voire 60% si vous avez souscrit chez une banque réputée pour être onéreuse. Fortuneo et ING Direct 
									se démarquent avec la gratuité des services bancaires même pour la demande d’une carte.
								</p>
								
								<h3 id="d200">Je ne suis pas contre l’autonomie</h3>
								<p>
									Contrairement à un établissement physique, vous serez en totale autonomie puisque toutes les simulations, 
									les demandes de conseils, les entretiens s’effectueront en ligne. Ce sera aussi le cas pour les transactions, 
									et même l’ouverture du compte. L’accès à internet est indispensable que ce soit via un ordinateur ou un Smartphone.
								</p>
								<p>
									Toutefois, cette gestion autonome est extrêmement attractive puisque <strong>vous serez en mesure de consulter vos relevés, 
									vos virements 24h/24 et surtout 7j/7</strong>. Inutile d’attendre les horaires d’ouverture, votre compte en ligne est disponible 
									tout au long de la journée même le week-end et les jours fériés alors qu’un établissement physique n’offrira pas une 
									telle souplesse.
								</p>
								
								<h3 id="d300">J’ai des revenus adaptés</h3>
								<p>
									Cette solution est également à votre portée si vos revenus sont au-delà de 750 euros. 
									Cette restriction est problématique, sauf chez ING Direct, qui a fait un véritable effort. 
									Ses offres sont donc disponibles pour un panel plus important contrairement à BForBank, 
									Hello Bank et Boursorama Banque, qui demandent plus de 1200€/mois.
								</p>
								<p>
									De son côté, Monabanq souhaite accueillir tous les foyers, mais la levée de cette limitation 
									a pour conséquence la mise en place de certains frais, il faudra verser 2€/mois 
									pour la gestion du compte et de la carte.
								</p>	
							</div>
						</div>
					</div>
					<div class="col-md-6">
						<img src="img/d/banque-virtuelle.jpg" class="img-responsive img-full-width" alt="banque online pour vous">
					</div>
				</div>
			</div>
		</div>	
		
		<div class="e-block block">
			<div class="container">
			 	<h2 id="e000">Comment se passe le passage d’une banque traditionnelle vers une banque «&nbsp;virtuelle&nbsp;»&nbsp;?</h2>
			 	
			 	<div class="row">
					<div class="col-md-5 col-md-offset-1">
						<h3 id="e100">L’ouverture du compte en ligne</h3>
						<p>
							Toutes les démarches sont effectuées sur la plateforme que ce soit pour la signature du contrat, 
							son envoi ainsi que sa validation. Quelques conditions sont tout de même demandées, vous devez 
							être majeur et résidez en France. Si toutefois, l’ouverture d’une banque en ligne concerne un mineur, 
							les parents devront fournir une autorisation ainsi qu’une copie du livret de famille.
						</p>
						
						<h4 id="e110">Quels sont les documents nécessaires pour ouvrir un compte en ligne&nbsp;?</h4>
						<ul>
							<li>La copie d’une pièce d’identité (carte de séjour, passeport…) qui doit être à jour</li>
							<li>Un justificatif de domicile de moins de six mois (quittance de loyer, facture d’électricité…) qui est généralement demandé par toutes les banques virtuelles, sauf chez Monabanq, qui se démarque de la concurrence</li>
							<li>Un justificatif des revenus des trois derniers mois</li>
							<li>Un chèque d’ouverture de compte dont le montant dépendra des conditions établies par la banque en ligne.</li>
						</ul>

						<p>
							Il est important de noter que le contact humain est supprimé lors de l’ouverture, mais vous devrez tout de même signer le contrat. 
							La signature sera numérisée après avoir scanné tous les documents préalablement remplis qu’il faudra transmettre 
							par mail ou via le formulaire mis à disposition par la banque.
						</p>	

						<p>
							Pour un établissement traditionnel, il est généralement nécessaire d’attendre plusieurs jours 
							entre la date du premier rendez-vous et l’ouverture réelle du compte. Avec une banque en ligne, 
							le délai est ramené à 48 heures si tous les documents demandés ont été fournis et si les conditions 
							ont été respectées notamment au niveau des revenus.
						</p>	
					</div>
					<div class="col-md-5">
						<h3 id="e200">Le transfert automatique vers la nouvelle banque</h3>

						<p>
							À ce stade, votre compte chez une banque en ligne est opérationnel, vous devez désormais vous occuper du transfert. 
							Il est important de lister les créanciers ainsi que les débiteurs, car il sera nécessaire de délivrer des <abbr title="Relevé d'Identité Bancaire">RIB</abbr> 
							pour que les versements et les prélèvements soient effectués sur le nouveau compte.
						</p>

						<p>
							Certaines banques sont en mesure de s’occuper de toutes les démarches, c’est le cas de Fortuneo qui a mis en 
							place un service à la fois simple et gratuit. Cette banque en ligne s’occupe des virements et des prélèvements 
							pour le salaire, les assurances, le gaz, l’électricité ou encore le téléphone. Elle informera tous les organismes.
						</p>
						
						<p>	
							Le transfert vers une banque virtuelle est donc extrêmement simple, il suffira d’inscrire 
							dans l’interface le changement de domiciliation bancaire en listant tous les organismes. 
							Il est important de noter qu’il est gratuit, mais, si la banque traditionnelle applique des frais, 
							l’e-banque propose généralement de les rembourser.
						</p>	

						<h3 id="e300">La clôture de l’ancien compte</h3>
						
						<p>
							Désormais, tous les organismes ont été avertis, le compte en ligne est opérationnel, 
							il est temps de clôturer le compte de l’établissement physique. Vérifiez au préalable 
							que tous les chèques ont été encaissés. Adressez ensuite une lettre de clôture à la banque 
							qui se devrait se plier à votre demande sous une dizaine de jours. À ce stade, les chéquiers 
							et les cartes bancaires deviendront obsolètes.
						</p>	
			 		</div>
			 	</div>
			</div>
		</div>	 		
		
		<div class="f-block block blue-block">
			<div class="container">
			 	<h2 id="f000">Combien de clients ont adopté ces nouvelles banques en ligne&nbsp;?</h2>
			 	
			 	<div class="row">
					<div class="col-md-4">
						<h3 id="f100">Une progression de 4 points en 6 mois</h3>
						<p>
							Une étude réalisée à la fin 2014 montrait que 7% des Français avaient opté pour un compte courant 100% en ligne. 
							Un an plus tard, <a href="http://www.audirep.fr/static/PJ/AUDIREP_ETUDE%20_Banque_en_ligne_Oct2014.pdf">Audirep a réalisé une enquête</a> pour le compte de BforBank. 
							Les résultats ont prouvé que la banque en ligne possédait de véritables atouts puisque 11% des Français 
							ont sauté le pas. Par conséquent, c’est une hausse non négligeable de plus de 4 points qui a été identifiée en, seulement, quelques mois.
						</p>
					</div>
					<div class="col-md-4">
						<h3 id="f200">Boursorama Banque est leader sur le marché</h3>
						<p>
							<a href="http://www.ingdirect.fr/ing-direct/qui-sommes-nous/">Au 31 décembre 2015, ING Direct rassemblait plus d’un million de clients</a>, 330 000 possèdent un compte courant. 
							Chez Boursorama Banque, ils sont 757 000 à avoir été séduits par le panel d’offres. Cette enseigne espère atteindre 
							son objectif fixé pour 2020, il consiste à atteindre les deux millions de clients. Au vu de la progression 
							de cette banque en ligne, il y a de grandes chances pour que ce vœu soit exaucé. En ce qui concerne 
							Fortuneo et Hello Bank, elles s’offrent respectivement 365 000 et 237 000 clients contre 135 000 pour BforBank.
						</p>	

						<p>
							<strong>Cette progression fulgurante du nombre de clients est expliquée par la baisse des frais 
							et la confiance accordée à ces établissements virtuels.</strong>
						</p>
					</div>
					<div class="col-md-4">
						<h3 id="f300">Demain, la progression sera encore plus fulgurante</h3>
						<p>
							Comme la confiance est au rendez-vous, Audirep estime selon cette même étude que le nombre de clients 
							sera beaucoup plus important. Ce seront donc 7 Français sur 10 qui posséderont un compte en ligne. 
							De telles banques ont un avenir prometteur puisqu’elles devraient occuper une place primordiale 
							grâce à un grand éventail de produits.
						</p>	

						<p>
							<strong>69% des sondés ont précisé qu’ils étaient prêts à ouvrir un compte chez une banque 
							online pour qu’elle devienne leur établissement principal.</strong> Il est important de noter que 
							cette intention est à l’origine d’une progression de deux points en seulement six mois.
						</p>
					</div>
				</div>		
			 </div>
		</div>
		<div class="g-block block">
			<div class="container">
				<div class="row">
					<div class="col-md-10 col-md-offset-1">
					 	<h2 id="g000">Doit-on avoir peur du piratage informatique&nbsp;?</h2>
					 	
					 	<div class="content">
						 	<img src="img/g/clavier-inviolable.jpg" class="img-responsive pull-right" alt="clavier numérique inviolable">
						 	<h3 id="g100">Utilisation d’un clavier numérique inviolable</h3>
						 	<p>
						 		Lorsque vous souhaitez vous connecter, il est nécessaire de renseigner un numéro de compte et un mot de passe. 
						 		Ces données ne sont pas transmises via le clavier physique, mais grâce à un clavier numérique. 
						 		Ce dernier a l’avantage d’être à l’abri des virus permettant d’identifier les touches 
						 		utilisées puisque les numéros seront sélectionnés avec la souris.
						 	</p>
					 	</div>
		
					 	<div class="content">
							<img src="img/g/donnee-cryptee.jpg" class="img-responsive pull-left" alt="données cryptées">
						 	<h3 id="g200">Les données sont cryptées avant d’être transférées</h3>
						 	<p>
						 		Certes, les cyberattaques prolifèrent sur le Web, mais les organismes bancaires ont utilisé de nombreuses solutions 
						 		pour repousser les pirates en informatique. Comme pour certains Français, le sujet de la sécurité informatique 
						 		est important, il est primordial de l’évoquer. Il est judicieux de noter que les risques encourus ne sont pas 
						 		plus nombreux lors de la consultation d’un compte en ligne via un établissement physique. Si vous êtes déjà un adepte 
						 		de cette méthode online, vous n’aurez aucune crainte à avoir.
						 	</p>
						 	<p>
						 		La banque en ligne a toutefois mis en place des protections, dont le cryptage des données via le <abbr title="Secure Socket Layer">SSL</abbr>. 
						 		Lorsque vous souhaitez vous connecter à votre compte, toutes les informations seront cryptées avant d’être transportées. 
						 		Cette technologie a l’avantage de renforcer la confidentialité ainsi que l’authentification.
						 	</p>
						 	<p>
						 		Par exemple, depuis un ordinateur ou un appareil mobile, vous êtes invités à partager des données de connexion. 
						 		Celles-ci sont envoyées au serveur de la banque en ligne, mais le transfert ne se fait pas à découvert 
						 		puisqu’elles se retrouvent dans un coffre blindé que les pirates ne pourront pas ouvrir.	
						 	</p>
						</div>	
		
						<div class="content">
							<img src="img/g/protection-bancaire.jpg" class="img-responsive pull-right" alt="code spécial opération bancaire">
						 	<h3 id="g300">Un code spécial pour certaines opérations</h3>
						 	<p>
						 		Votre compte en ligne vous donne accès à toutes les modifications, aux virements, à la gestion de l’épargne… 
						 		Par conséquent, les organismes virtuels ont mis en place un code d’authentification supplémentaire 
						 		qu’il faudra renseigner pour que cette opération soit effective. Il sera envoyé par <abbr title="Short Message Service">SMS</abbr>, ce qui garantit 
						 		au maximum les transactions. Il sera nécessaire pour la réalisation d’un virement, l’inscription d’un nouveau destinataire, 
						 		la connexion depuis un poste de travail inhabituel, un changement de coordonnées…
						 	</p>
						 	<p>
						 		<strong>La sécurité est maximale sur les banques en ligne, il n’y a aucune crainte à avoir en ce qui concerne un piratage informatique. 
						 		Dans tous les cas, le risque ne sera pas plus important, mais la protection est au rendez-vous.</strong>
						 	</p>
						</div>
					 </div>	
				</div>
			</div>	
		</div>	 	
		
		<hr />
		
		<div class="h-block block">
			<div class="container">
			 	<h2 id="h000">Les applications mobiles et les banques en ligne</h2>
			
				<div class="row">
					<div class="col-md-6">
						<div class="scrollable">
							<div class="movable">
								<h3 id="h100">Une compatibilité avec iOS, Windows Phone et Android</h3>	
								<p>
									Ces organismes ont l’avantage d’être 100% compatibles avec le Web, elles ont donc été contraintes 
									de se renforcer dans le secteur du mobile puisqu’il est devenu le meilleur ami de l’Homme. Le Smartphone 
									est toujours présent dans la poche, un sac, une veste, sur la table… Les banques en ligne 
									proposent donc diverses solutions. Pratiquement <strong>toutes les enseignes ont recours à une application 
									disponible sur iOS, Android et Windows Phone</strong>. Vous pouvez ainsi consulter votre compte 
									à tout moment dès que vous le souhaitez.
								</p>
								
								
								<h3 id="h200">Les 5 fonctionnalités les plus intéressantes</h3>
								<p>Ces applications bancaires présentent cinq opérations qui ont le mérite d’être les plus courantes&nbsp;:</p>
								<ul>
									<li>Contacter un conseiller financier ou discuter via un tchat même pendant vos déplacements</li>
									<li>Obtenir les numéros utiles pour faire opposition à vos moyens de paiement</li>
									<li>Localiser immédiatement le distributeur le plus proche</li>
									<li>Réaliser des virements internes pour vos comptes ou externes pour vos créanciers</li>
									<li>Consulter et gérer votre épargne et votre compte courant</li>
								</ul>
								
								<h3 id="h300">Une application mobile est plus attractive qu’un site mobile</h3>
								<p>
									Au fil des demandes des clients, il y a de grandes chances pour que les banques en 
									ligne enrichissent davantage sur les fonctionnalités à apporter. La Société Générale 
									se penche pour Boursorama Banque sur une «&nbsp;enveloppe de dépense&nbsp;». Cet outil aurait 
									la particularité de vous apporter quelques données supplémentaires concernant votre budget.
								</p>
								<p>
									L’application mobile reste un choix stratégique, elle apporte un réel confort, mais 
									certains organismes décident de développer seulement un site mobile. Ce dernier 
									est moins pratique, mais il est tout de même adapté aux Smartphones et aux tablettes. 
									Au niveau des fonctionnalités, ce seront les mêmes que celles visibles sur une version 
									Web avec quelques désagréments supplémentaires au niveau de la navigation.
								</p>
								
								<h3 id="h400">Soon, une banque 100% mobile</h3>
								<p>
									Les particuliers sont en mesure d’ouvrir un compte chez Soon qui a la particularité 
									d’être <a href="https://www.soon.fr/">une banque en ligne 100% mobile</a>. Il n’y a donc pas d’agence ni de version Web.
									Toutes les opérations seront effectuées uniquement via le Smartphone. Plusieurs avantages sont au rendez-vous&nbsp;:
								</p>
								<ul>
									<li>La carte bancaire est gratuite</li>
									<li>Aucune condition de revenus n’est utilisée</li>
									<li>Les frais bancaires sont gratuits pour les opérations courantes</li>
									<li>Le tchat client est ouvert 24h/24 et 6j/7</li>
									<li>40€ sont nécessaires pour ouvrir un compte</li>
									<li>Les dépenses sont catégorisées</li>
									<li>L’application est disponible sur Android et iOS</li>
								</ul>
							</div>
						</div>
					</div>
					<div class="col-md-6">
						<img src="img/h/mobile-banque-online.jpg" class="img-responsive img-full-width" alt="applications mobiles banque">
					</div>
				</div>
			</div>
		</div>	
		
		<div class="i-block block">
			<div class="container">
				<h2 id="i000">Quelles sont les banques en ligne disponibles&nbsp;?</h2>
			
				<div class="row">
					<div class="col-md-10 col-md-offset-1">
						<h3 id="i100">Quelle est la différence entre une banque en ligne et une version hybride&nbsp;?</h3>
						<p>
							La liste n’est pas exhaustive, car il est nécessaire de faire la différence entre un organisme bancaire 
							100% digital et une banque hybride. Cette dernière est <strong>rattachée à une agence, ce qui entraîne les frais courants</strong>, 
							mais une version Web est disponible. Vous pouvez donc gérer vos comptes grâce à une interface sur internet, 
							mais pour déposer un chèque, il faudra par exemple se plier à la file d’attente.
						</p>
						<p>
							A contrario, <strong>les banques 100% en ligne ont supprimées ce concept d’agence</strong>, ce qui permet d’effectuer 
							d’importantes économies. Toutes les opérations s’effectueront par le biais de la toile.
						</p>
						
						<h3 id="i200">Six banques en ligne sont à la disposition des clients</h3>
						<p>
							Lorsque l’on prend en compte uniquement les formats 100% Web, nous avons une liste plus petite. 
							La comparaison des offres sera essentielle, car leur catalogue met en avant quelques spécificités. 
							En France, vous aurez le choix entre&nbsp;:
						</p>
						<ul>
							<li><a href="https://www.boursorama-banque.com">Boursorama Banque</a> de la Société Générale</li>
							<li><a href="https://www.fortuneo.fr/">Fortuneo</a> du Crédit Mutuel</li>
							<li><a href="https://www.monabanq.com">Monabanq</a> du Crédit Mutuel/CIC</li>
							<li><a href="http://www.ingdirect.fr/">ING Direct</a> du groupe ING</li>
							<li><a href="https://www.hellobank.fr">Hello Bank</a> de BNP Paribas</li>
							<li><a href="https://www.bforbank.com/">BforBank</a> du groupe Crédit Agricole</li>
						</ul>	
					</div>
				</div>
			</div>		
		</div>
			
		<div class="j-block block">
			<div class="container">	
				<h2 id="j000">Quels sont les produits proposés par les banques en ligne&nbsp;?</h2>
				
				<div class="row">
					<div class="col-md-10 col-md-offset-1">
						<p>Les banques en ligne disposent d’un catalogue comprenant quatre familles de produits&nbsp;:</p>
						<ul>
							<li>Le compte courant</li>	
							<li>Les solutions d’épargne</li>	
							<li>Les crédits</li>	
							<li>La Bourse</li>	
						</ul>
						
						<p>
							Dans le détail, nous pouvons identifier 12 produits qui auront l’avantage de s’adapter à tous les profils. 
							Certains critères permettent toutefois de réduire facilement le choix. En effet, toutes les banques en ligne 
							ne disposent pas d’un crédit immobilier ou à la consommation. Le concept est identique pour les différents livrets, 
							notamment celui proposé pour les jeunes.
						</p>
					</div>
				</div>	
				<div class="table-responsive">
				<table class="table table-striped colored">
					<thead>
						<tr>
							<th class="empty"></th>
							<th class="item">Boursorama<br />Banque</th>
							<th class="item">Fortuneo</th>
							<th class="item">Hello Bank</th>
							<th class="item">ING Direct</th>
							<th class="item">Monabanq</th>
							<th class="item">BforBank</th>
							<th class="item">Soon</th>
						</tr>
					</thead>
					<tbody>
						<tr>
							<th scope="row">Carte bancaire</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
						</tr>	
						<tr>
							<th scope="row">Assurance moyen de paiement</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
						</tr>	
						<tr>
							<th scope="row">Conseiller dédié</th>
							<td><span class="glyphicon glyphicon-remove"></span></td> 
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row">Bonus Livret</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row">Livret A</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row"><abbr title="Plan Epargne Logement">PEL</abbr>-<abbr title="Compte Epargne Logement">CEL</abbr></th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row">Livret Jeune</th>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row"><abbr title="Livret de Développement Durable">LDD</abbr></th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row">Assurance vie</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row">Crédit immobilier</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row">Crédit consommation</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
						<tr>
							<th scope="row">Bourse</th>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-ok"></span></td>
							<td><span class="glyphicon glyphicon-remove"></span></td>
						</tr>	
					</tbody>
				</table>
				</div>
			</div>
		</div>	
			
		<div class="k-block block">
			<div class="container">	
				<h2 id="k000">Les banques en ligne sont-elles adaptées aux professionnels&nbsp;?</h2>
				
				<div class="row">
					<div class="col-md-10 col-md-offset-1">
						<h3 id="k100">Un choix idéal pour les petites entreprises</h3>
						<p>
							Généralement, ce sont les particuliers qui cherchent par tous les moyens à réduire les frais en choisissant 
							la meilleure banque. Toutefois, les professionnels sont eux aussi invités à opter pour ce procédé digital. 
							Contrairement aux établissements physiques, toutes les banques en ligne ne disposent pas d’un catalogue 
							adapté à une telle activité.
						</p>
						<p>
							Cette souscription serait surtout adaptée aux patrons de petites entreprises ou aux autoentrepreneurs, 
							dont les besoins se rapprochent de ceux d’un particulier. Cela leur permet d’économiser sur les 
							frais bancaires tout en bénéficiant de la gratuité d’une carte bancaire.
						</p>
						<p>
							Par la suite, les banques en ligne sont en mesure de vous accompagner dans votre évolution professionnelle 
							notamment en facilitant les démarches pour le financement d’une entreprise plus importante.
						</p>
						
						<h3 id="k200">Quels sont les documents nécessaires pour ouvrir son compte entreprise&nbsp;?</h3>
						<p>
							Pour l’ouverture d’un compte en tant que professionnel, vous aurez besoins d’un justificatif d’immatriculation 
							au répertoire des métiers ou au registre du commerce et des sociétés. Dans certains cas de figure, 
							il sera nécessaire de fournir le numéro <abbr title="Système d'Identification du Répertoire des Entreprises ">SIREN</abbr>, le code <abbr title="Activité Principale Exercée">APE</abbr>, le bail commercial ainsi que les statuts de la société.
						</p>
					</div>
				</div>
			</div>
		</div>			
			
		<hr />	
			
		<div class="l-block block">
			<div class="container">	
				<h2 id="l000">Quelques conseils pour réussir son expérience avec une banque en ligne</h2>
				
				<div class="row">
					<div class="col-md-5 col-md-offset-1">
						<p>
							Le passage d’un établissement classique à une banque totalement électronique peut effrayer, 
							mais, en suivant ces conseils, tout se passera à merveille. Vous ne pourrez plus vous passer de cette banque 
							en ligne qui finalement présente de sérieux atouts.
						</p>
						
						<h3 id="l100">Accepter les alertes personnalisées</h3>
						<p>
							Ces organismes digitaux ont construit une plateforme susceptible de vous informer via SMS ou par mail 
							si un problème survient sur votre compte. Ces alertes limitent au maximum d’éventuels frais supplémentaires. 
							Cette gestion minutieuse vous permettra d’accroître les économies, en plus de celles réalisées par la 
							disparition de certains coûts.
						</p>
						
						<h3 id="l200">Apprendre à utiliser toutes les technologies</h3>
						<p>
							Une connexion internet est un critère indispensable, elle devra être sécurisée au maximum. Il est donc déconseillé 
							de se connecter à votre compte dans un lieu public où le WiFi n’est pas privé. Lorsque cet environnement est idéal, 
							vous devrez vous pencher sur l’interface de la banque en ligne en apprenant à connaître toutes les subtilités&nbsp;: 
							contact du conseiller, virements, prélèvements, commandes… Cette démarche devra aussi concerner les applications mobiles. 
							Avec ce petit temps d’adaptation, la banque en ligne n’aura plus aucun secret et vous n’aurez pas de mauvaises surprises.
						</p>
					</div>
					<div class="col-md-5">
						<h3 id="l300">Sécuriser la connexion avec un vrai mot de passe</h3>
						<p>
							Les banques online sont sécurisées grâce à des clés de chiffrement. Si vous êtes victime d’un piratage, 
							votre mot de passe sera sans doute responsable. 
						</p>
						<h4 id="l310">Comment sécuriser son compte&nbsp;?</h4>
						<ul>
							<li>Vérifier la présence du cadenas dans la barre d’adresse</li>
							<li>Choisir un mot de passe complexe et unique qui n’a pas de relation avec votre quotidien</li>
							<li>Ne pas opter pour la connexion automatique</li>
							<li>Changer régulièrement votre mot de passe</li>
							<li>Ne jamais transmettre votre mot de passe par voie électronique</li>
						</ul>
						
						<p>
							La vigilance est aussi de mise lorsque vous consultez vos mails, il ne faut donc pas cliquer sur un lien 
							transmis dans un courriel. En cas de doute, il suffit de joindre la banque en ligne ou de rejoindre son 
							compte avec l’adresse officielle.
						</p>
						<p>
							Enfin, ne communiquez jamais vos coordonnées bancaires même si le mail a tendance à prendre l’apparence d’un organisme digital.
						</p>
					</div>
				</div>
			</div>
		</div>			
			
		<div class="m-block block">
			<div class="container">	
				<h2 id="m000">FAQ</h2>
				
				<div class="question">
					<h3 id="m100">Pourquoi les prix sont-ils si bas&nbsp;? Les banques en ligne sont-elles légales&nbsp;?</h3>
					<div class="content">
						<p>
							Certains frais peuvent éveiller des soupçons, mais vous pouvez avoir confiance, 
							car la disparition de ces coûts ou leur réduction drastique s’explique par l’absence d’agences. 
							Ces dernières demandent un investissement colossal qui est compensé par les frais bancaires. 
							Comme la banque virtuelle existe uniquement sur le Web, aucun frais de ce genre n’est nécessaire.
						</p>	
					</div>
				</div>
				<div class="question">
					<h3 id="m200">Les banques en ligne sont-elles sérieuses&nbsp;?</h3>
					<div class="content">
						<p>
							Lorsque le concept a été lancé, la peur des Français a freiné leur envie, mais celle-ci n’était pas impactée 
							par divers produits. Le manque de clarté des informations était à l’origine de ce manque de confiance. 
							Les groupes bancaires ont donc déployé des structures sécurisées à l’échelle internationale pour combler 
							les attentes des clients. Pour vous connecter, vous aurez donc à votre disposition un clavier virtuel et 
							une technologie de pointe pour la saisie du mot de passe.
						</p>
						
						<p>
							Les banques virtuelles sont liées généralement à de grands groupes à la fois efficaces et pertinents. 
							Boursorama Banque appartient à la Société Générale, Fortuneo et Monabanq sont dans les rangs du Crédit Mutuel. 
							Les garanties proposées sont donc similaires à celles dévoilées par les entreprises mères, ce qui est un 
							gage de qualité. Par conséquent, sans le savoir, vous connaissez parfaitement les banques en ligne puisqu’elles 
							sont régies par une maison mère très renommée.
						</p>
						
						<p>	
							De plus, pour offrir une sécurité maximale, elles disposent d’un antivirus, d’un anti-spyware, et même d’un pare-feu.
						</p>	
					</div>
				</div>
				<div class="question">
					<h3 id="m300">Pourrais-je parler à un conseiller&nbsp;?</h3>
					<div class="content">
						<p>
							C’est souvent la plus grande crainte des réfractaires, car l’absence d’agence n’est pas le synonyme 
							de l’absence d’un conseiller. Il est disponible du lundi au samedi de 8h à 22h. Il suffit d’envoyer un courrier, 
							un mail, d’utiliser le téléphone, le tchat et la visioconférence si vous êtes équipé d’une Webcam ou les forums. 
							Les banques en ligne ont pu s’adapter aux nouvelles tendances, elles ont donc développé des plateformes collaboratives 
							tout en optimisant la relation clientèle sur Facebook et Twitter.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m400">Comment effectuer des virements&nbsp;?</h3>
					<div class="content">
						<p>
							Avec un établissement physique, vous deviez vous rendre au guichet et attendre de longues minutes pour virer de l’argent. 
							Désormais, le concept est novateur, il suffit de vous connecter à votre compte 100% sécurisé et de cliquer 
							sur l’opération souhaitée via votre interface. Après avoir inscrit un montant, il sera nécessaire de renseigner 
							le <abbr title="Relevé d'Identité Bancaire">RIB</abbr> et de valider. En quelques secondes, la somme est envoyée au destinataire et vous avez gagné de longues minutes.
						</p>
						<p>
							Un petit avantage est à noter, les virements en ligne via ces banques virtuelles ont la particularité d’être gratuits, 
							ce qui n’est pas forcément le cas pour un organisme bancaire classique. 
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m500">Comment déposer des chèques&nbsp;?</h3>
					<div class="content">
						<p>
							Lors de la souscription, une adresse postale vous sera communiquée, il suffira de les envoyer si toutefois 
							la banque en ligne n’est pas une filiale. A contrario, vous pourrez déposer vos chèques à un guichet 
							d’une société mère comme la Société Générale pour Boursorama Banque.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m600">Comment retirer de l’argent&nbsp;?</h3>
					<div class="content">
						<p>
							Lorsque votre compte aura été validé, vous pourrez utiliser votre carte bancaire obtenue gratuitement. 
							Cette dernière vous donne le droit de retirer de l’argent dans tous les distributeurs automatiques de France 
							et en Europe sans frais.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m700">Comment choisir une banque en ligne&nbsp;?</h3>
					<div class="content">
						<p>
							Les banques numériques ont développé des solutions adaptées à tous les profils. Il suffit de comparer 
							les différentes offres pour sélectionner la meilleure. Il faudra accorder une importance particulière 
							aux offres promotionnelles, au montant minimum pour l’ouverture du compte, au rendement de l’épargne, aux divers frais. 
						</p>	
					</div>
				</div>
				<div class="question">
					<h3 id="m800">Une banque en ligne autorise-t-elle les crédits&nbsp;?</h3>
					<div class="content">
						<p>
							Les organismes bancaires virtuels ont renforcé leurs offres, leur catalogue prend donc en compte 
							de nombreux crédits qu’ils soient en lien avec l’immobilier, la consommation, l’automobile… 
							Avant de choisir une banque en ligne, il est judicieux de se pencher sur ce sujet, car elles 
							ne possèdent pas le même panel d’avantages.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m900">Vais-je réaliser des économies&nbsp;?</h3>
					<div class="content">
						<p>
							L’association CLCV <a href="http://www.clcv.org/images/CLCV/fichiers/banqueassurancefinancier/enquban2015/DOSSIER_PRESSE_2015.pdf">s’est penchée sur ce sujet pour 2015</a>, 
							elle a constaté que les frais bancaires dans les établissements physiques avaient subi une hausse de 4, voire 5%. 
							En faisant appel à une banque en ligne, ce seront près de 150 euros qui seront économisés tous les ans. 
							Un bon moyen pour s’offrir un beau cadeau ou payer une partie de ses vacances.
							
							Cela est possible, car les e-banques n’ont pas d’agences, elles sont en mesure de favoriser la gratuité de la tenue du compte, 
							la carte bancaire tout en réduisant les frais générés par quelques services. Selon l’association, ING Direct et 
							Boursorama Banque sont les moins chères, elles se positionnent devant Fortuneo, Hello Bank, BforBank puis Monabanq.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m1000">L’épargne est-elle plus intéressante avec une banque en ligne&nbsp;?</h3>
					<div class="content">
						<p>
							Le rendement des <abbr title="Livret de Développement Durable">LDD</abbr>, <abbr title="Plan Epargne Logement">PEL</abbr> et Livret A sont fixés par l’État, les établissements virtuels et physiques 
							ne sont pas en mesure de l’améliorer. Par contre, les banques virtuelles proposent parfois «&nbsp;un super livret&nbsp;» 
							susceptible d’afficher des taux très intéressants.
						</p>
						<p>
							En parallèle, l’assurance-vie s’avère être plus attractive avec des rendements qui peuvent atteindre 
							près de 3.50% contre 2.30% en moyenne pour les banques traditionnelles.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m1100">Les incidents bancaires sont-ils plus avantageux&nbsp;?</h3>
					<div class="content">
						<p>
							Les banques en ligne se démarquent à nouveau puisque les frais sont moins élevés. Les incidents bancaires pèsent moins lourd. 
							Par exemple, la commission d’intervention est gratuite chez tous les organismes sauf Hello Bank et Monabanq. 
							À titre de comparaison, il est intéressant d’insister sur le fait que le Crédit Agricole facture cette commission huit 
							euros par opération avec un plafond de 80 euros par mois.
						</p>
						<p>
							Il faudra également compter 20 euros pour le rejet d’un prélèvement à cause d’un solde insuffisant et, 
							si le rejet concerne un chèque, les frais n'excèdent pas 50 euros.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m1200">Les banques en ligne délivrent-elles un chèque de banque&nbsp;?</h3>
					<div class="content">
						<p>
							Chez Fortuneo, Boursorama Banque et Bforbank, il suffit d’émettre une commande depuis votre interface. 
							Le système est identique à celui nécessaire pour l’envoi d’un chéquier. Il faudra renseigner le destinataire, 
							le montant ainsi que le code transmis par SMS. Selon les établissements, cette émission sera gratuite ou légèrement payante.
						</p>
					</div>
				</div>
				<div class="question">
					<h3 id="m1300">Quelle est leur politique en matière de carte sans contact&nbsp;?</h3>
					<div class="content">
						<p>
							Les banques en ligne délivrent ces fameuses cartes, mais chez Fortuneo, BforBank et Boursorama banque, 
							le client décide ou non d’activer la technologie avec un simple bouton présent dans l’interface.
						</p>
						
						<p>
							Par contre, l’activation sera par défaut chez ING Direct et Hello Bank. 
							Ces deux organismes ne vous laisseront pas le choix contrairement à Monabanq, qui vous permettra de désactiver 
							la fonction grâce à un coup de téléphone.
						</p>	
					</div>
				</div>
			</div>
		</div>	
		<div class="block conclusion-block blue-block">
			<div class="container">
				<div class="row">
					<div class="col-md-12">
						Tous les noms de produits, de marques et de logos déposés sont la propriété de leurs propriétaires respectifs.
					</div>
				</div>
				<div class="row">
					<div class="col-md-6">
						<strong>Echo / Banque en ligne est édité par LNPO SARL</strong><br />
						SARL au capital de 100&nbsp;€<br />
						RCS Paris B&nbsp;491&nbsp;142&nbsp;873<br />
						Code APE 7022Z<br />
						Siège social : 4 rue de la Gaité – 91270 Vigneux sur Seine – France<br />
						Directeur de la publication : Florian DAVID<br />
						Contact : webmaster&nbsp;[at]&nbsp;echo.cx
					</div>
					<div class="col-md-6">
						<strong>Echo / Banque en ligne est hébergé par GANDI SAS</strong><br />
						SAS au capital de 300&nbsp;000&nbsp;€<br />
						RCS Paris 423&nbsp;093&nbsp;459<br />
						Siège social : 63-65 boulevard Massena – 75013 Paris – France<br />
						Téléphone : <a href="tel:+33(0)1.70.37.76.61">+33(0) 1 70 37 76 61</a><br />
						Télécopie : <a href="tel:+33(0)1.43.73.18.51">+33(0) 1 43 73 18 51</a><br />
						Directeur de la publication : Nicolas LHUILLERY<br />
						Contact : direction [at] gandi.net<br />
					</div>
				</div>
			</div>
		</div>
		<link rel="stylesheet" type="text/css" href="https://fonts.googleapis.com/css?family=Open+Sans:400,400i,700,700i">
		<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
		<link rel="stylesheet" type="text/css" href="css.css" />
		
		<script>
		  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		
		  ga('create', 'UA-85104955-1', 'auto');
		  ga('send', 'pageview');

		  var trackOutboundLink = function(url) {
			   ga('send', 'event', 'outbound', 'click', url, {
			     'transport': 'beacon',
			     'hitCallback': function(){document.location = url;}
			   });
			}
			
		</script>		
	</body>
</html>	