diff --git a/README.md b/README.md
index 49e5d94..fd5f930 100644
--- a/README.md
+++ b/README.md
@@ -76,28 +76,36 @@ client = WeTransfer::Client.new(api_key: ENV.fetch('WT_API_KEY'))
 ```
 
 Now that you've got the client set up you can use  `create_transfer_and_upload_files` to, well, create a transfer, and upload all files!
+The upload of all files will be performed at the end of the block. Depending on your file sizes and network connection speed, this might take some time.
 
 ```ruby
 transfer = client.create_transfer_and_upload_files(message: 'All the Things') do |transfer|
-  # Add a file using File.open. If you do it like this, :name and :io params are optional
-  transfer.add_file(io: File.open('Gemfile'))
+  # Add files to the transfer, using add_file.
 
-  # Add a file with File.open, but give it a different name inside the transfer
-  transfer.add_file(
-    name: 'hello_world.rb',
-    io: File.open('path/to/file/with/different_name.rb')
-  )
-
-  # Using :name, :size and :io params.
+  # Making use of :name, :size and :io params.
   # Specifying the size is not very useful in this case, but feel free to explicitly
   # communicate the size of the coming io.
+  # Probably it is safer to not use the size param. But if you do use it, make sure it is correct!
   #
-  # The :name param is compulsory if it cannot be derived from the IO.
+  # The :name param is compulsory, since it cannot be derived from the IO.
   transfer.add_file(
     name: 'README.txt',
     size: 31,
     io: StringIO.new("You should read All the Things!")
   )
+
+  # Add a file with File.open, renaming the file inside the transfer.
+  # If you omit the size param, the SDK calls `size` on the io, and uses that.
+  transfer.add_file(
+    name: 'hello_world.rb',
+    io: File.open('path/to/file/with/different_name.rb')
+  )
+
+  # If you invoke add_file that has a File instance in the io param, the :name and :io params are
+  # optional.
+  # Using add_file like this will result in the SDK calling guessing the name of the io,
+  # by invoking `File.basename(io)`.
+  transfer.add_file(io: File.open('Gemfile'))
 end
 
 # To get a link to your transfer, call `url` on your transfer object:
@@ -132,9 +140,7 @@ transfer.to_h # =>
 # }
 ```
 
-The upload will be performed at the end of the block. Depending on your file sizes and network connection speed, this might take some time.
-
-What are you waiting for? Open that link in your browser! Chop chop.
+What are you waiting for? Create a transfer. Add some files. Open that link in your browser! Chop chop.
 
 If you want to have more control over which files uploads when, it is also possible.
 
@@ -227,7 +233,7 @@ Bug reports and pull requests are welcome on GitHub at <https://github.com/wetra
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT) - the in-repo version of the license is [here](https://github.com/WeTransfer/wetransfer_ruby_sdk/blob/master/LICENSE.txt).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT) - the in-repo version of the license is [here](https://github.com/WeTransfer/EmbedExamples/blob/master/LICENSE.txt).
 
 ## Code of Conduct
 
diff --git a/lib/we_transfer/transfer.rb b/lib/we_transfer/transfer.rb
index 769c467..1aeb44b 100644
--- a/lib/we_transfer/transfer.rb
+++ b/lib/we_transfer/transfer.rb
@@ -5,6 +5,7 @@ class Transfer
     class DuplicateFileNameError < ArgumentError; end
     class NoFilesAddedError < StandardError; end
     class FileMismatchError < StandardError; end
+    class NothingToUploadError < ArgumentError; end
 
     extend Forwardable
 
@@ -53,27 +54,38 @@ def add_file(**args)
     # Upload the file. Convenience method for uploading the parts of the file in
     # chunks. This will upload all chunks in order, single threaded.
     #
-    # @param  :name [String] The name used to add the file to the transfer
+    # @param  :id [optional, String] The id as returned when creating the transfer
     # @param  :io [optional, String] The contents to be uploaded. If the file was
     #         added (See Transfer#add_file) including an io, this can be omitted.
     #         If the file was added including an io, *and* it is included in this
     #         call, the io from this invocation will be uploaded.
     # @param :file [optional, WeTransferFile] The file instance that will be
     #         uploaded.
+    # Be aware that although all params are optional, you can only upload files
+    # if at least an id and an io are provided, of a file is provided.
     #
-    # @raise  [WeTransfer::RemoteFile::NoIoError] Will be raised if the io does
+    # @raise  [WeTransfer::Transfer::NothingToUploadError] Will be raised if
+    #         the io / id pair or a file is una
     #         not meet the minimal requirements (see MiniIo.mini_io_able?)
     # @example
     #
     # @see MiniIo.mini_io_able?
-    def upload_file(name:, io: nil, file: nil)
-      file ||= find_file(name)
-      put_io = io || file.io
+    def upload_file(id: nil, io: nil, file: nil)
+      begin
+        file ||= find_file(id)
+        put_io = io || file.io
+      rescue; end # do nothing; we raise if the expected params are missing
+      raise(
+        WeTransfer::Transfer::NothingToUploadError,
+        "Provide at least a :file, or a combination of :id and :io params."
+      ) unless (id && (io || file.io)) || file
 
+      # Do we still need next raise?
       raise(
         WeTransfer::RemoteFile::NoIoError,
-        "IO for file with name '#{name}' cannot be uploaded."
+        "IO for file with id '#{id}' cannot be uploaded."
       ) unless WeTransfer::MiniIO.mini_io_able?(put_io)
+
       (1..file.multipart.chunks).each do |chunk|
         put_url = upload_url_for_chunk(file_id: file.id, chunk: chunk)
         chunk_contents = StringIO.new(put_io.read(file.multipart.chunk_size))
@@ -90,25 +102,26 @@ def upload_file(name:, io: nil, file: nil)
     def upload_files
       files.each do |file|
         upload_file(
-          name: file.name,
+          id: file.id,
           file: file
         )
       end
       self
     end
 
-    def upload_url_for_chunk(file_id: nil, name: nil, chunk:)
-      raise ArgumentError, "missing keyword: either name or file_id is required" unless file_id || name
+    def upload_url_for_chunk(file_id: nil, chunk:)
+      raise ArgumentError, "missing keyword: either name or file_id is required" unless file_id
 
-      file_id ||= find_file(name).id
       @communicator.upload_url_for_chunk(id, file_id, chunk)
     end
 
-    def complete_file(file: nil, name: file&.name, file_id: file&.id)
-      raise ArgumentError, "missing keyword: either name or file is required" unless file || name || file_id
+    def complete_file(file: nil, name: nil, id: file&.id)
+      WeTransfer.logger.warn("[DEPRECATION]: name kw argument is deprecated") unless name.nil?
+      raise ArgumentError, "missing keyword: either name or file is required" unless file || id
+      return @communicator.complete_file(self.id, file.id, file.multipart.chunks) if file
 
-      file ||= find_file(name || file_id)
-      @communicator.complete_file(id, file.id, file.multipart.chunks)
+      amount_of_chunks = find_file(id).multipart.chunks
+      @communicator.complete_file(self.id, id, amount_of_chunks)
     end
 
     def complete_files
@@ -147,19 +160,19 @@ def to_h
 
     # Find a file inside this transfer
     #
-    # @param  [String] name_or_id, The name (as set by you) or the id (as returned)
-    #         by WeTransfer Public API of the file.
+    # @param  [String] id, The id, as returned by WeTransfer Public API, of the file.
+    #         This may also be the name of the file, which can be handy during the
+    #         create_transfer call: It allows caching without having an id yey
     # @raise  [FileMismatchError] if a file with that name or id cannot be found for
     #         this transfer
     # @return [WeTransferFile] The file you requested
     #
-    def find_file(name_or_id)
-      @found_files ||= Hash.new do |h, name_or_id|
-        h[name_or_id] = files.find { |file| [file.name, file.id].include? name_or_id }
+    def find_file(id)
+      @found_files ||= Hash.new do |h, id|
+        h[id] = files.find { |file| [file.id, file.name].include?(id) }
       end
-
-      raise FileMismatchError unless @found_files[name_or_id]
-      @found_files[name_or_id]
+      raise FileMismatchError unless @found_files[id]
+      @found_files[id]
     end
   end
 end
diff --git a/lib/we_transfer/we_transfer_file.rb b/lib/we_transfer/we_transfer_file.rb
index 27ba0c2..bc7d4b6 100644
--- a/lib/we_transfer/we_transfer_file.rb
+++ b/lib/we_transfer/we_transfer_file.rb
@@ -10,7 +10,7 @@ class WeTransferFile
     # isn't provided, but the io can provide it.
     #
     # @param  :io [optional, anything] The io of the file. This will be wrapped
-    #         in a MiniIo, or if absent in a NullMiniIo
+    #         in a MiniIo, or (if absent) wrapped in a NullMiniIo.
     # @param  :name [optional, String] The name you want to give your file. This
     #          does not have to match the original file name.
     # @param  :size [optional, Numeric] The size of the file. Has to be exact to
diff --git a/spec/features/client_creates_a_transfer_spec.rb b/spec/features/client_creates_a_transfer_spec.rb
index dc3e687..f31d934 100644
--- a/spec/features/client_creates_a_transfer_spec.rb
+++ b/spec/features/client_creates_a_transfer_spec.rb
@@ -56,4 +56,44 @@
     expect(transfer.url)
       .to match %r|https://we.tl/t-|
   end
+
+  # # This test uses different transfer objects for the 4 different steps, so we isolate behavior
+  # # of all cases as much as possible
+  # it "handles diacritics in file names well", :focus do
+  #   name_with_diacritics = "file-name-with-diacritics-äëüïö.jpg".freeze
+
+  #   transfer = client.create_transfer(message: "test transfer") do |transfer|
+  #     transfer.add_file(
+  #       name: name_with_diacritics,
+  #       size: 10,
+  #       io: StringIO.new("#" * 10)
+  #     )
+  #   end
+
+  #   transfer.upload_file(name: name_with_diacritics)
+  #   transfer.complete_file(name: name_with_diacritics)
+  #   transfer.finalize
+  # end
+
+  it "handles diacritics in file names well" do
+    name_with_diacritics = "file-name-with-diacritics-äëüïö.jpg".freeze
+
+    create_transfer = client.create_transfer(message: "test transfer") do |transfer|
+      transfer.add_file(
+        name: name_with_diacritics,
+        size: 10,
+      )
+    end
+
+    file_id = create_transfer.find_file(name_with_diacritics).id
+
+    upload_file_transfer = client.find_transfer(create_transfer.id)
+    upload_file_transfer.upload_file(id: file_id, io: StringIO.new("#" * 10))
+
+    complete_file_transfer = client.find_transfer(create_transfer.id)
+    complete_file_transfer.complete_file(id: file_id)
+
+    finalize_transfer = client.find_transfer(create_transfer.id)
+    finalize_transfer.finalize
+  end
 end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index e92f5b9..978534f 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -27,3 +27,5 @@
 end
 
 RSpec::Mocks.configuration.verify_partial_doubles = true
+
+WeTransfer.logger = Logger.new(STDOUT)
diff --git a/spec/we_transfer/transfer_spec.rb b/spec/we_transfer/transfer_spec.rb
index 27c52bb..da76bdf 100644
--- a/spec/we_transfer/transfer_spec.rb
+++ b/spec/we_transfer/transfer_spec.rb
@@ -3,6 +3,16 @@
 describe WeTransfer::Transfer do
   let(:communicator) { instance_double(WeTransfer::Communicator) }
 
+  describe "Error classes" do
+    it "NothingToUploadError is a subtype of ArgumentError" do
+      expect(
+        WeTransfer::Transfer::NothingToUploadError
+          .new
+          .is_a?(ArgumentError)
+      ).to eq true
+    end
+  end
+
   describe ".create" do
     it "instantiates a transfer" do
       expect(described_class)
@@ -68,16 +78,15 @@
           message: "test transfer",
           communicator: communicator
         )
-      }
-        .to_not raise_error
+      }.to_not raise_error
     end
 
-    it "fails without a :message" do
+    it "fails without a :message param" do
       expect { described_class.new(communicator: communicator) }
         .to raise_error ArgumentError, %r|message|
     end
 
-    it "fails without a :communicator" do
+    it "fails without a :communicator param" do
       expect { described_class.new(message: "test transfer") }
         .to raise_error ArgumentError, %r|communicator|
     end
@@ -252,11 +261,25 @@
       )
     end
 
-    it "should be called with :name" do
-      transfer.add_file(name: "test file", size: 8)
+    context "called without :file, without :id, without :io params" do
+      it "raises" do
+        expect { transfer.upload_file }
+          .to raise_error WeTransfer::Transfer::NothingToUploadError, %r|file.*id.*io|
+      end
+    end
 
-      expect { transfer.upload_file }
-        .to raise_error ArgumentError, %r|name|
+    context "called with :id and with :io params" do
+      it "doesn't raise" do
+        expect { transfer.upload_file(id: 'fake', io: StringIO.new("a")) }
+          .to_not raise_error WeTransfer::Transfer::NothingToUploadError
+      end
+    end
+
+    context "called with :file param" do
+      it "doesn't raise" do
+        expect { transfer.upload_file(file: double(WeTransfer::WeTransferFile)) }
+          .to_not raise_error WeTransfer::Transfer::NothingToUploadError
+      end
     end
 
     context "without io keyword param," do
@@ -286,7 +309,7 @@
             .to receive(:upload_chunk)
             .with("https://fake.upload.url/123", kind_of(StringIO))
 
-          transfer.upload_file(name: "test file")
+          transfer.upload_file(id: "fake-file-id")
         end
 
         it "invokes :upload_url_for_chunk to obtain a PUT url" do
@@ -312,31 +335,21 @@
             .to receive(:upload_url_for_chunk)
             .with(file_id: "fake-file-id", chunk: 1)
 
-          transfer.upload_file(name: "test file")
+          transfer.upload_file(id: "fake-file-id")
         end
       end
-
-      it "breaks if the WeTransferFile instance does not have an io" do
-        transfer.add_file(name: "test file", size: 8)
-
-        expect { transfer.upload_file(name: "test file") }
-          .to raise_error WeTransfer::RemoteFile::NoIoError, %r|'test file' cannot be uploaded|
-      end
     end
 
     context "uploads each chunk" do
-      it "upload is triggered once if the io smaller than the server's chunk size" do
-        file_name = "test file"
-        contents = "12345678"
-
-        transfer.add_file(name: file_name, io: StringIO.new(contents))
+      it "upload is triggered once if the io is smaller than the server's chunk size" do
+        transfer.add_file(name: "test file", io: StringIO.new("12345678"))
 
         # transfer.persist # does a network call
         # fake-persist the transfer so we can spec the complete_file run
         multipart = instance_double(
           WeTransfer::RemoteFile::Multipart,
           chunks: 1,
-          chunk_size: 20
+          chunk_size: 8,
         )
         transfer.instance_variable_set :@id, 'fake-transfer-id'
         transfer.files.each do |f|
@@ -353,7 +366,7 @@
           .and_return("https://signed.url/123")
           .once
 
-        transfer.upload_file(name: file_name)
+        transfer.upload_file(id: 'fake-file-id')
       end
 
       it "upload is triggered twice if the io is has 2 chunks" do
@@ -386,7 +399,7 @@
           .with(%r|https://fake.upload.url/big-chunk-\d|, kind_of(StringIO))
           .exactly(2).times
 
-        transfer.upload_file(name: file_name)
+        transfer.upload_file(id: 'fake-file-id')
       end
     end
   end
@@ -399,14 +412,13 @@
       )
     end
 
-    let(:file_factory) { Struct.new(:name) }
-
     it "invokes :upload_file for each file in the files collection" do
+      file_factory = Struct.new(:id)
       transfer.instance_variable_set(:@files, 2.times.map { |n| file_factory.new("file-#{n}") })
 
       expect(transfer)
         .to receive(:upload_file)
-        .with(hash_including(:file, :name))
+        .with(hash_including(:file, :id))
         .twice
 
       transfer.upload_files
@@ -426,7 +438,7 @@
         .to raise_error(ArgumentError, %r|chunk|)
     end
 
-    it "must be invoked with either a :file_id or :name kw param" do
+    it "must be invoked with a :file_id or :name kw param" do
       expect { transfer.upload_url_for_chunk(chunk: :foo) }
         .to raise_error(ArgumentError, %r|name.*file_id|)
 
@@ -436,9 +448,6 @@
       transfer.add_file(name: 'bar', size: 8)
       transfer.files.first.instance_variable_set :@id, 'baz'
 
-      expect { transfer.upload_url_for_chunk(chunk: :foo, name: 'bar') }
-        .not_to raise_error
-
       expect { transfer.upload_url_for_chunk(chunk: :foo, file_id: 'baz') }
         .not_to raise_error
     end
@@ -470,7 +479,7 @@
     let(:file) {
       instance_double(
         WeTransfer::WeTransferFile,
-        id: 8,
+        id: 'fake-file-id',
         name: 'meh',
         multipart: multipart
       )
@@ -485,7 +494,7 @@
     }
 
     it "can be invoked with a :name kw param" do
-      transfer.add_file(name: 'meh', size: 8)
+      transfer.add_file(name: 'meh', size: 20)
 
       # fake-persist the transfer so we can spec the complete_file run
       transfer.instance_variable_set :@id, 'fake-transfer-id'
@@ -497,24 +506,31 @@
       expect(communicator)
         .to receive(:complete_file)
 
-      transfer.complete_file(name: 'meh')
+      transfer.complete_file(id: 'fake-file-id')
     end
 
     it "can be invoked with a :file kw param" do
+      transfer.add_file(name: file.name, size: 12)
+
+      transfer.instance_variable_set :@id, 'fake-transfer-id'
+      transfer.files.each do |f|
+        f.instance_variable_set :@id, 'fake-file-id'
+        f.instance_variable_set :@multipart, multipart
+      end
+
       allow(communicator)
         .to receive(:complete_file)
 
       transfer.complete_file(file: file)
     end
 
-    it "if invoked with both a :name or a :file param, the :file is used" do
+    it "if invoked with both a :id or a :file param, the :file takes precedence" do
       allow(communicator)
         .to receive(:complete_file)
-
       expect(transfer)
         .to_not receive(:find_file)
 
-      transfer.complete_file(name: 'foo', file: file)
+      transfer.complete_file(id: 'fake-file-id', file: file)
     end
 
     it "needs to be invoked with either a :name or a :file kw param" do